errors: raise RemoteError in some places in exchange.py

This is part of https://www.mercurial-scm.org/wiki/ErrorCategoriesPlan

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

mercurial/exchange.py

@@ -1,2819 +1,2819 b''
 # exchange.py - utility to exchange data between repos.
 #
 # Copyright 2005-2007 Olivia 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 . import (
     bookmarks as bookmod,
     bundle2,
     bundlecaches,
     changegroup,
     discovery,
     error,
     exchangev2,
     lock as lockmod,
     logexchange,
     narrowspec,
     obsolete,
     obsutil,
     phases,
     pushkey,
     pycompat,
     requirements,
     scmutil,
     streamclone,
     url as urlmod,
     util,
     wireprototypes,
 )
 from .utils import (
     hashutil,
     stringutil,
     urlutil,
 )
 
 urlerr = util.urlerr
 urlreq = util.urlreq
 
 _NARROWACL_SECTION = b'narrowacl'
 
 
 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.CanceledError(_(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'
             )
         )
     for category in sorted(bundle2.read_remote_wanted_sidedata(pushop.remote)):
         # Check that a computer is registered for that category for at least
         # one revlog kind.
         for kind, computers in repo._sidedata_computers.items():
             if computers.get(category):
                 break
         else:
             raise error.Abort(
                 _(
                     b'cannot push: required sidedata category not supported'
                     b" by this client: '%s'"
                 )
                 % pycompat.bytestr(category)
             )
     # 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(pushop.repo, 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)
 
     remote_sidedata = bundle2.read_remote_wanted_sidedata(pushop.remote)
     cgstream = changegroup.makestream(
         pushop.repo,
         pushop.outgoing,
         version,
         b'push',
         bundlecaps=b2caps,
         remote_sidedata=remote_sidedata,
     )
     cgpart = bundler.newpart(b'changegroup', data=cgstream)
     if cgversions:
         cgpart.addparam(b'version', version)
     if scmutil.istreemanifest(pushop.repo):
         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(pushop.repo, 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)
+            raise error.RemoteError(_(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)
+            raise error.RemoteError(_(b'missing support for %s') % exc)
         except bundle2.AbortFromPart as exc:
             pushop.ui.error(_(b'remote: %s\n') % exc)
             if exc.hint is not None:
                 pushop.ui.error(_(b'remote: %s\n') % (b'(%s)' % exc.hint))
-            raise error.Abort(_(b'push failed on remote'))
+            raise error.RemoteError(_(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, urlutil.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 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(b"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)
 
     for category in repo._wanted_sidedata:
         # Check that a computer is registered for that category for at least
         # one revlog kind.
         for kind, computers in repo._sidedata_computers.items():
             if computers.get(category):
                 break
         else:
             # This should never happen since repos are supposed to be able to
             # generate the sidedata they require.
             raise error.ProgrammingError(
                 _(
                     b'sidedata category requested by local side without local'
                     b"support: '%s'"
                 )
                 % pycompat.bytestr(category)
             )
 
     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)
 
     remote_sidedata = bundle2.read_remote_wanted_sidedata(pullop.remote)
     if remote_sidedata:
         kwargs[b'remote_sidedata'] = remote_sidedata
 
     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.error(_(b'remote: abort: %s\n') % exc)
-            raise error.Abort(_(b'pull failed on remote'), hint=exc.hint)
+            raise error.RemoteError(_(b'pull failed on remote'), hint=exc.hint)
         except error.BundleValueError as exc:
-            raise error.Abort(_(b'missing support for %s') % exc)
+            raise error.RemoteError(_(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,
     remote_sidedata=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,
                 remote_sidedata=remote_sidedata,
             ),
         )
 
     # 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,
             remote_sidedata=remote_sidedata,
             **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,
     remote_sidedata=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,
         remote_sidedata=remote_sidedata,
     )
 
     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 scmutil.istreemanifest(repo):
         part.addparam(b'treemanifest', b'1')
 
     if b'exp-sidedata-flag' in repo.requirements:
         part.addparam(b'exp-sidedata', b'1')
         sidedata = bundle2.format_remote_wanted_sidedata(repo)
         part.addparam(b'exp-wanted-sidedata', sidedata)
 
     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(repo, 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, urlutil.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 = bundlecaches.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 = bundlecaches.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 = bundlecaches.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 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

tests/test-bookmarks-pushpull.t

@@ -1,1396 +1,1396 b''
 #testcases b2-pushkey b2-binary
 
 #if b2-pushkey
   $ cat << EOF >> $HGRCPATH
   > [devel]
   > legacy.exchange=bookmarks
   > EOF
 #endif
 
 #require serve
 
   $ cat << EOF >> $HGRCPATH
   > [command-templates]
   > log={rev}:{node|short} {desc|firstline}
   > [phases]
   > publish=False
   > [experimental]
   > evolution.createmarkers=True
   > evolution.exchange=True
   > EOF
 
   $ cat > $TESTTMP/hook.sh <<'EOF'
   > echo "test-hook-bookmark: $HG_BOOKMARK:  $HG_OLDNODE -> $HG_NODE"
   > EOF
   $ TESTHOOK="hooks.txnclose-bookmark.test=sh $TESTTMP/hook.sh"
 
 initialize
 
   $ hg init a
   $ cd a
   $ echo 'test' > test
   $ hg commit -Am'test'
   adding test
 
 set bookmarks
 
   $ hg bookmark X
   $ hg bookmark Y
   $ hg bookmark Z
 
 import bookmark by name
 
   $ hg init ../b
   $ cd ../b
   $ hg book Y
   $ hg book
    * Y                         -1:000000000000
   $ hg pull ../a --config "$TESTHOOK"
   pulling from ../a
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   adding remote bookmark X
   updating bookmark Y
   adding remote bookmark Z
   added 1 changesets with 1 changes to 1 files
   new changesets 4e3505fd9583 (1 drafts)
   test-hook-bookmark: X:   -> 4e3505fd95835d721066b76e75dbb8cc554d7f77
   test-hook-bookmark: Y:  0000000000000000000000000000000000000000 -> 4e3505fd95835d721066b76e75dbb8cc554d7f77
   test-hook-bookmark: Z:   -> 4e3505fd95835d721066b76e75dbb8cc554d7f77
   (run 'hg update' to get a working copy)
   $ hg bookmarks
      X                         0:4e3505fd9583
    * Y                         0:4e3505fd9583
      Z                         0:4e3505fd9583
   $ hg debugpushkey ../a namespaces
   bookmarks	
   namespaces	
   obsolete	
   phases	
   $ hg debugpushkey ../a bookmarks
   X	4e3505fd95835d721066b76e75dbb8cc554d7f77
   Y	4e3505fd95835d721066b76e75dbb8cc554d7f77
   Z	4e3505fd95835d721066b76e75dbb8cc554d7f77
 
 delete the bookmark to re-pull it
 
   $ hg book -d X
   $ hg pull -B X ../a
   pulling from ../a
   no changes found
   adding remote bookmark X
 
 finally no-op pull
 
   $ hg pull -B X ../a
   pulling from ../a
   no changes found
   $ hg bookmark
      X                         0:4e3505fd9583
    * Y                         0:4e3505fd9583
      Z                         0:4e3505fd9583
 
 export bookmark by name
 
   $ hg bookmark W
   $ hg bookmark foo
   $ hg bookmark foobar
   $ hg push -B W ../a
   pushing to ../a
   searching for changes
   no changes found
   exporting bookmark W
   [1]
   $ hg -R ../a bookmarks
      W                         -1:000000000000
      X                         0:4e3505fd9583
      Y                         0:4e3505fd9583
    * Z                         0:4e3505fd9583
 
 delete a remote bookmark
 
   $ hg book -d W
 
 #if b2-pushkey
 
   $ hg push -B W ../a --config "$TESTHOOK" --debug --config devel.bundle2.debug=yes
   pushing to ../a
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   no changes found
   bundle2-output-bundle: "HG20", 4 parts total
   bundle2-output: start emission of HG20 stream
   bundle2-output: bundle parameter: 
   bundle2-output: start of parts
   bundle2-output: bundle part: "replycaps"
   bundle2-output-part: "replycaps" 224 bytes payload
   bundle2-output: part 0: "REPLYCAPS"
   bundle2-output: header chunk size: 16
   bundle2-output: payload chunk size: 224
   bundle2-output: closing payload chunk
   bundle2-output: bundle part: "check:bookmarks"
   bundle2-output-part: "check:bookmarks" 23 bytes payload
   bundle2-output: part 1: "CHECK:BOOKMARKS"
   bundle2-output: header chunk size: 22
   bundle2-output: payload chunk size: 23
   bundle2-output: closing payload chunk
   bundle2-output: bundle part: "check:phases"
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output: part 2: "CHECK:PHASES"
   bundle2-output: header chunk size: 19
   bundle2-output: payload chunk size: 24
   bundle2-output: closing payload chunk
   bundle2-output: bundle part: "pushkey"
   bundle2-output-part: "pushkey" (params: 4 mandatory) empty payload
   bundle2-output: part 3: "PUSHKEY"
   bundle2-output: header chunk size: 90
   bundle2-output: closing payload chunk
   bundle2-output: end of bundle
   bundle2-input: start processing of HG20 stream
   bundle2-input: reading bundle2 stream parameters
   bundle2-input-bundle: with-transaction
   bundle2-input: start extraction of bundle2 parts
   bundle2-input: part header size: 16
   bundle2-input: part type: "REPLYCAPS"
   bundle2-input: part id: "0"
   bundle2-input: part parameters: 0
   bundle2-input: found a handler for part replycaps
   bundle2-input-part: "replycaps" supported
   bundle2-input: payload chunk size: 224
   bundle2-input: payload chunk size: 0
   bundle2-input-part: total payload size 224
   bundle2-input: part header size: 22
   bundle2-input: part type: "CHECK:BOOKMARKS"
   bundle2-input: part id: "1"
   bundle2-input: part parameters: 0
   bundle2-input: found a handler for part check:bookmarks
   bundle2-input-part: "check:bookmarks" supported
   bundle2-input: payload chunk size: 23
   bundle2-input: payload chunk size: 0
   bundle2-input-part: total payload size 23
   bundle2-input: part header size: 19
   bundle2-input: part type: "CHECK:PHASES"
   bundle2-input: part id: "2"
   bundle2-input: part parameters: 0
   bundle2-input: found a handler for part check:phases
   bundle2-input-part: "check:phases" supported
   bundle2-input: payload chunk size: 24
   bundle2-input: payload chunk size: 0
   bundle2-input-part: total payload size 24
   bundle2-input: part header size: 90
   bundle2-input: part type: "PUSHKEY"
   bundle2-input: part id: "3"
   bundle2-input: part parameters: 4
   bundle2-input: found a handler for part pushkey
   bundle2-input-part: "pushkey" (params: 4 mandatory) supported
   pushing key for "bookmarks:W"
   bundle2-input: payload chunk size: 0
   bundle2-input: part header size: 0
   bundle2-input: end of bundle2 stream
   bundle2-input-bundle: 4 parts total
   running hook txnclose-bookmark.test: sh $TESTTMP/hook.sh
   test-hook-bookmark: W:  0000000000000000000000000000000000000000 -> 
   bundle2-output-bundle: "HG20", 1 parts total
   bundle2-output: start emission of HG20 stream
   bundle2-output: bundle parameter: 
   bundle2-output: start of parts
   bundle2-output: bundle part: "reply:pushkey"
   bundle2-output-part: "reply:pushkey" (params: 0 advisory) empty payload
   bundle2-output: part 0: "REPLY:PUSHKEY"
   bundle2-output: header chunk size: 43
   bundle2-output: closing payload chunk
   bundle2-output: end of bundle
   bundle2-input: start processing of HG20 stream
   bundle2-input: reading bundle2 stream parameters
   bundle2-input-bundle: no-transaction
   bundle2-input: start extraction of bundle2 parts
   bundle2-input: part header size: 43
   bundle2-input: part type: "REPLY:PUSHKEY"
   bundle2-input: part id: "0"
   bundle2-input: part parameters: 2
   bundle2-input: found a handler for part reply:pushkey
   bundle2-input-part: "reply:pushkey" (params: 0 advisory) supported
   bundle2-input: payload chunk size: 0
   bundle2-input: part header size: 0
   bundle2-input: end of bundle2 stream
   bundle2-input-bundle: 1 parts total
   deleting remote bookmark W
   listing keys for "phases"
   [1]
 
 #endif
 #if b2-binary
 
   $ hg push -B W ../a --config "$TESTHOOK" --debug --config devel.bundle2.debug=yes
   pushing to ../a
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   no changes found
   bundle2-output-bundle: "HG20", 4 parts total
   bundle2-output: start emission of HG20 stream
   bundle2-output: bundle parameter: 
   bundle2-output: start of parts
   bundle2-output: bundle part: "replycaps"
   bundle2-output-part: "replycaps" 224 bytes payload
   bundle2-output: part 0: "REPLYCAPS"
   bundle2-output: header chunk size: 16
   bundle2-output: payload chunk size: 224
   bundle2-output: closing payload chunk
   bundle2-output: bundle part: "check:bookmarks"
   bundle2-output-part: "check:bookmarks" 23 bytes payload
   bundle2-output: part 1: "CHECK:BOOKMARKS"
   bundle2-output: header chunk size: 22
   bundle2-output: payload chunk size: 23
   bundle2-output: closing payload chunk
   bundle2-output: bundle part: "check:phases"
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output: part 2: "CHECK:PHASES"
   bundle2-output: header chunk size: 19
   bundle2-output: payload chunk size: 24
   bundle2-output: closing payload chunk
   bundle2-output: bundle part: "bookmarks"
   bundle2-output-part: "bookmarks" 23 bytes payload
   bundle2-output: part 3: "BOOKMARKS"
   bundle2-output: header chunk size: 16
   bundle2-output: payload chunk size: 23
   bundle2-output: closing payload chunk
   bundle2-output: end of bundle
   bundle2-input: start processing of HG20 stream
   bundle2-input: reading bundle2 stream parameters
   bundle2-input-bundle: with-transaction
   bundle2-input: start extraction of bundle2 parts
   bundle2-input: part header size: 16
   bundle2-input: part type: "REPLYCAPS"
   bundle2-input: part id: "0"
   bundle2-input: part parameters: 0
   bundle2-input: found a handler for part replycaps
   bundle2-input-part: "replycaps" supported
   bundle2-input: payload chunk size: 224
   bundle2-input: payload chunk size: 0
   bundle2-input-part: total payload size 224
   bundle2-input: part header size: 22
   bundle2-input: part type: "CHECK:BOOKMARKS"
   bundle2-input: part id: "1"
   bundle2-input: part parameters: 0
   bundle2-input: found a handler for part check:bookmarks
   bundle2-input-part: "check:bookmarks" supported
   bundle2-input: payload chunk size: 23
   bundle2-input: payload chunk size: 0
   bundle2-input-part: total payload size 23
   bundle2-input: part header size: 19
   bundle2-input: part type: "CHECK:PHASES"
   bundle2-input: part id: "2"
   bundle2-input: part parameters: 0
   bundle2-input: found a handler for part check:phases
   bundle2-input-part: "check:phases" supported
   bundle2-input: payload chunk size: 24
   bundle2-input: payload chunk size: 0
   bundle2-input-part: total payload size 24
   bundle2-input: part header size: 16
   bundle2-input: part type: "BOOKMARKS"
   bundle2-input: part id: "3"
   bundle2-input: part parameters: 0
   bundle2-input: found a handler for part bookmarks
   bundle2-input-part: "bookmarks" supported
   bundle2-input: payload chunk size: 23
   bundle2-input: payload chunk size: 0
   bundle2-input-part: total payload size 23
   bundle2-input: part header size: 0
   bundle2-input: end of bundle2 stream
   bundle2-input-bundle: 4 parts total
   running hook txnclose-bookmark.test: sh $TESTTMP/hook.sh
   test-hook-bookmark: W:  0000000000000000000000000000000000000000 -> 
   bundle2-output-bundle: "HG20", 0 parts total
   bundle2-output: start emission of HG20 stream
   bundle2-output: bundle parameter: 
   bundle2-output: start of parts
   bundle2-output: end of bundle
   bundle2-input: start processing of HG20 stream
   bundle2-input: reading bundle2 stream parameters
   bundle2-input-bundle: no-transaction
   bundle2-input: start extraction of bundle2 parts
   bundle2-input: part header size: 0
   bundle2-input: end of bundle2 stream
   bundle2-input-bundle: 0 parts total
   deleting remote bookmark W
   listing keys for "phases"
   [1]
 
 #endif
 
 Divergent bookmark cannot be exported
 
   $ hg book W@default
   $ hg push -B W@default ../a
   pushing to ../a
   searching for changes
   cannot push divergent bookmark W@default!
   no changes found
   [2]
   $ hg book -d W@default
 
 export the active bookmark
 
   $ hg bookmark V
   $ hg push -B . ../a
   pushing to ../a
   searching for changes
   no changes found
   exporting bookmark V
   [1]
 
 exporting the active bookmark with 'push -B .'
 demand that one of the bookmarks is activated
 
   $ hg update -r default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (leaving bookmark V)
   $ hg push -B . ../a
   abort: no active bookmark
   [255]
   $ hg update -r V
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (activating bookmark V)
 
 delete the bookmark
 
   $ hg book -d V
   $ hg push -B V ../a
   pushing to ../a
   searching for changes
   no changes found
   deleting remote bookmark V
   [1]
   $ hg up foobar
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark foobar)
 
 push/pull name that doesn't exist
 
   $ hg push -B badname ../a
   pushing to ../a
   searching for changes
   bookmark badname does not exist on the local or remote repository!
   no changes found
   [2]
   $ hg pull -B anotherbadname ../a
   pulling from ../a
   abort: remote bookmark anotherbadname not found!
   [10]
 
 divergent bookmarks
 
   $ cd ../a
   $ echo c1 > f1
   $ hg ci -Am1
   adding f1
   $ hg book -f @
   $ hg book -f X
   $ hg book
      @                         1:0d2164f0ce0d
    * X                         1:0d2164f0ce0d
      Y                         0:4e3505fd9583
      Z                         1:0d2164f0ce0d
 
   $ cd ../b
   $ hg up
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updating bookmark foobar
   $ echo c2 > f2
   $ hg ci -Am2
   adding f2
   $ hg book -if @
   $ hg book -if X
   $ hg book
      @                         1:9b140be10808
      X                         1:9b140be10808
      Y                         0:4e3505fd9583
      Z                         0:4e3505fd9583
      foo                       -1:000000000000
    * foobar                    1:9b140be10808
 
   $ hg pull --config paths.foo=../a foo --config "$TESTHOOK"
   pulling from $TESTTMP/a
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   divergent bookmark @ stored as @foo
   divergent bookmark X stored as X@foo
   updating bookmark Z
   added 1 changesets with 1 changes to 1 files (+1 heads)
   new changesets 0d2164f0ce0d (1 drafts)
   test-hook-bookmark: @foo:   -> 0d2164f0ce0d8f1d6f94351eba04b794909be66c
   test-hook-bookmark: X@foo:   -> 0d2164f0ce0d8f1d6f94351eba04b794909be66c
   test-hook-bookmark: Z:  4e3505fd95835d721066b76e75dbb8cc554d7f77 -> 0d2164f0ce0d8f1d6f94351eba04b794909be66c
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg book
      @                         1:9b140be10808
      @foo                      2:0d2164f0ce0d
      X                         1:9b140be10808
      X@foo                     2:0d2164f0ce0d
      Y                         0:4e3505fd9583
      Z                         2:0d2164f0ce0d
      foo                       -1:000000000000
    * foobar                    1:9b140be10808
 
 (test that too many divergence of bookmark)
 
   $ "$PYTHON" $TESTDIR/seq.py 1 100 | while read i; do hg bookmarks -r 000000000000 "X@${i}"; done
   $ hg pull ../a
   pulling from ../a
   searching for changes
   no changes found
   warning: failed to assign numbered name to divergent bookmark X
   divergent bookmark @ stored as @1
   $ hg bookmarks | grep '^   X' | grep -v ':000000000000'
      X                         1:9b140be10808
      X@foo                     2:0d2164f0ce0d
 
 (test that remotely diverged bookmarks are reused if they aren't changed)
 
   $ hg bookmarks | grep '^   @'
      @                         1:9b140be10808
      @1                        2:0d2164f0ce0d
      @foo                      2:0d2164f0ce0d
   $ hg pull ../a
   pulling from ../a
   searching for changes
   no changes found
   warning: failed to assign numbered name to divergent bookmark X
   divergent bookmark @ stored as @1
   $ hg bookmarks | grep '^   @'
      @                         1:9b140be10808
      @1                        2:0d2164f0ce0d
      @foo                      2:0d2164f0ce0d
 
   $ "$PYTHON" $TESTDIR/seq.py 1 100 | while read i; do hg bookmarks -d "X@${i}"; done
   $ hg bookmarks -d "@1"
 
   $ hg push -f ../a
   pushing to ../a
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   $ hg -R ../a book
      @                         1:0d2164f0ce0d
    * X                         1:0d2164f0ce0d
      Y                         0:4e3505fd9583
      Z                         1:0d2164f0ce0d
 
 explicit pull should overwrite the local version (issue4439)
 
   $ hg update -r X
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark X)
   $ hg pull --config paths.foo=../a foo -B . --config "$TESTHOOK"
   pulling from $TESTTMP/a
   no changes found
   divergent bookmark @ stored as @foo
   importing bookmark X
   test-hook-bookmark: @foo:  0d2164f0ce0d8f1d6f94351eba04b794909be66c -> 0d2164f0ce0d8f1d6f94351eba04b794909be66c
   test-hook-bookmark: X:  9b140be1080824d768c5a4691a564088eede71f9 -> 0d2164f0ce0d8f1d6f94351eba04b794909be66c
 
 reinstall state for further testing:
 
   $ hg book -fr 9b140be10808 X
 
 revsets should not ignore divergent bookmarks
 
   $ hg bookmark -fr 1 Z
   $ hg log -r 'bookmark()' --template '{rev}:{node|short} {bookmarks}\n'
   0:4e3505fd9583 Y
   1:9b140be10808 @ X Z foobar
   2:0d2164f0ce0d @foo X@foo
   $ hg log -r 'bookmark("X@foo")' --template '{rev}:{node|short} {bookmarks}\n'
   2:0d2164f0ce0d @foo X@foo
   $ hg log -r 'bookmark("re:X@foo")' --template '{rev}:{node|short} {bookmarks}\n'
   2:0d2164f0ce0d @foo X@foo
 
 update a remote bookmark from a non-head to a head
 
   $ hg up -q Y
   $ echo c3 > f2
   $ hg ci -Am3
   adding f2
   created new head
   $ hg push ../a --config "$TESTHOOK"
   pushing to ../a
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   test-hook-bookmark: Y:  4e3505fd95835d721066b76e75dbb8cc554d7f77 -> f6fc62dde3c0771e29704af56ba4d8af77abcc2f
   updating bookmark Y
   $ hg -R ../a book
      @                         1:0d2164f0ce0d
    * X                         1:0d2164f0ce0d
      Y                         3:f6fc62dde3c0
      Z                         1:0d2164f0ce0d
 
 update a bookmark in the middle of a client pulling changes
 
   $ cd ..
   $ hg clone -q a pull-race
 
 We want to use http because it is stateless and therefore more susceptible to
 race conditions
 
   $ hg serve -R pull-race -p $HGPORT -d --pid-file=pull-race.pid -E main-error.log
   $ cat pull-race.pid >> $DAEMON_PIDS
 
   $ cat <<EOF > $TESTTMP/out_makecommit.sh
   > #!/bin/sh
   > hg ci -Am5
   > echo committed in pull-race
   > EOF
 
   $ hg clone -q http://localhost:$HGPORT/ pull-race2 --config "$TESTHOOK"
   test-hook-bookmark: @:   -> 0d2164f0ce0d8f1d6f94351eba04b794909be66c
   test-hook-bookmark: X:   -> 0d2164f0ce0d8f1d6f94351eba04b794909be66c
   test-hook-bookmark: Y:   -> f6fc62dde3c0771e29704af56ba4d8af77abcc2f
   test-hook-bookmark: Z:   -> 0d2164f0ce0d8f1d6f94351eba04b794909be66c
   $ cd pull-race
   $ hg up -q Y
   $ echo c4 > f2
   $ hg ci -Am4
   $ echo c5 > f3
   $ cat <<EOF > .hg/hgrc
   > [hooks]
   > outgoing.makecommit = sh $TESTTMP/out_makecommit.sh
   > EOF
 
 (new config needs a server restart)
 
   $ cd ..
   $ killdaemons.py
   $ hg serve -R pull-race -p $HGPORT -d --pid-file=pull-race.pid -E main-error.log
   $ cat pull-race.pid >> $DAEMON_PIDS
   $ cd pull-race2
   $ hg -R $TESTTMP/pull-race book
      @                         1:0d2164f0ce0d
      X                         1:0d2164f0ce0d
    * Y                         4:b0a5eff05604
      Z                         1:0d2164f0ce0d
   $ hg pull
   pulling from http://localhost:$HGPORT/
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   updating bookmark Y
   added 1 changesets with 1 changes to 1 files
   new changesets b0a5eff05604 (1 drafts)
   (run 'hg update' to get a working copy)
   $ hg book
    * @                         1:0d2164f0ce0d
      X                         1:0d2164f0ce0d
      Y                         4:b0a5eff05604
      Z                         1:0d2164f0ce0d
 
 Update a bookmark right after the initial lookup -B (issue4689)
 
   $ echo c6 > ../pull-race/f3 # to be committed during the race
   $ cat <<EOF > $TESTTMP/listkeys_makecommit.sh
   > #!/bin/sh
   > if hg st | grep -q M; then
   >     hg commit -m race
   >     echo committed in pull-race
   > else
   >     exit 0
   > fi
   > EOF
   $ cat <<EOF > ../pull-race/.hg/hgrc
   > [hooks]
   > # If anything to commit, commit it right after the first key listing used
   > # during lookup. This makes the commit appear before the actual getbundle
   > # call.
   > listkeys.makecommit= sh $TESTTMP/listkeys_makecommit.sh
   > EOF
   $ restart_server() {
   >  "$TESTDIR/killdaemons.py" $DAEMON_PIDS
   >  hg serve -R ../pull-race -p $HGPORT -d --pid-file=../pull-race.pid -E main-error.log
   >  cat ../pull-race.pid >> $DAEMON_PIDS
   > }
   $ restart_server # new config need server restart
   $ hg -R $TESTTMP/pull-race book
      @                         1:0d2164f0ce0d
      X                         1:0d2164f0ce0d
    * Y                         5:35d1ef0a8d1b
      Z                         1:0d2164f0ce0d
   $ hg update -r Y
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (activating bookmark Y)
   $ hg pull -B .
   pulling from http://localhost:$HGPORT/
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   updating bookmark Y
   added 1 changesets with 1 changes to 1 files
   new changesets 35d1ef0a8d1b (1 drafts)
   (run 'hg update' to get a working copy)
   $ hg book
      @                         1:0d2164f0ce0d
      X                         1:0d2164f0ce0d
    * Y                         5:35d1ef0a8d1b
      Z                         1:0d2164f0ce0d
 
 Update a bookmark right after the initial lookup -r (issue4700)
 
   $ echo c7 > ../pull-race/f3 # to be committed during the race
   $ cat <<EOF > ../lookuphook.py
   > """small extensions adding a hook after wireprotocol lookup to test race"""
   > import functools
   > from mercurial import wireprotov1server, wireprotov2server
   > 
   > def wrappedlookup(orig, repo, *args, **kwargs):
   >     ret = orig(repo, *args, **kwargs)
   >     repo.hook(b'lookup')
   >     return ret
   > for table in [wireprotov1server.commands, wireprotov2server.COMMANDS]:
   >   table[b'lookup'].func = functools.partial(wrappedlookup, table[b'lookup'].func)
   > EOF
   $ cat <<EOF > ../pull-race/.hg/hgrc
   > [extensions]
   > lookuphook=$TESTTMP/lookuphook.py
   > [hooks]
   > lookup.makecommit= sh $TESTTMP/listkeys_makecommit.sh
   > EOF
   $ restart_server # new config need server restart
   $ hg -R $TESTTMP/pull-race book
      @                         1:0d2164f0ce0d
      X                         1:0d2164f0ce0d
    * Y                         6:0d60821d2197
      Z                         1:0d2164f0ce0d
   $ hg pull -r Y
   pulling from http://localhost:$HGPORT/
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   updating bookmark Y
   added 1 changesets with 1 changes to 1 files
   new changesets 0d60821d2197 (1 drafts)
   (run 'hg update' to get a working copy)
   $ hg book
      @                         1:0d2164f0ce0d
      X                         1:0d2164f0ce0d
    * Y                         6:0d60821d2197
      Z                         1:0d2164f0ce0d
   $ hg -R $TESTTMP/pull-race book
      @                         1:0d2164f0ce0d
      X                         1:0d2164f0ce0d
    * Y                         7:714424d9e8b8
      Z                         1:0d2164f0ce0d
 
 (done with this section of the test)
 
   $ killdaemons.py
   $ cd ../b
 
 diverging a remote bookmark fails
 
   $ hg up -q 4e3505fd9583
   $ echo c4 > f2
   $ hg ci -Am4
   adding f2
   created new head
   $ echo c5 > f2
   $ hg ci -Am5
   $ hg log -G
   @  5:c922c0139ca0 5
   |
   o  4:4efff6d98829 4
   |
   | o  3:f6fc62dde3c0 3
   |/
   | o  2:0d2164f0ce0d 1
   |/
   | o  1:9b140be10808 2
   |/
   o  0:4e3505fd9583 test
   
 
   $ hg book -f Y
 
   $ cat <<EOF > ../a/.hg/hgrc
   > [web]
   > push_ssl = false
   > allow_push = *
   > EOF
 
   $ hg serve -R ../a -p $HGPORT2 -d --pid-file=../hg2.pid
   $ cat ../hg2.pid >> $DAEMON_PIDS
 
   $ hg push http://localhost:$HGPORT2/
   pushing to http://localhost:$HGPORT2/
   searching for changes
   abort: push creates new remote head c922c0139ca0 with bookmark 'Y'
   (merge or see 'hg help push' for details about pushing new heads)
   [20]
   $ hg -R ../a book
      @                         1:0d2164f0ce0d
    * X                         1:0d2164f0ce0d
      Y                         3:f6fc62dde3c0
      Z                         1:0d2164f0ce0d
 
 
 Unrelated marker does not alter the decision
 
   $ hg debugobsolete aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
   1 new obsolescence markers
   $ hg push http://localhost:$HGPORT2/
   pushing to http://localhost:$HGPORT2/
   searching for changes
   abort: push creates new remote head c922c0139ca0 with bookmark 'Y'
   (merge or see 'hg help push' for details about pushing new heads)
   [20]
   $ hg -R ../a book
      @                         1:0d2164f0ce0d
    * X                         1:0d2164f0ce0d
      Y                         3:f6fc62dde3c0
      Z                         1:0d2164f0ce0d
 
 Update to a successor works
 
   $ hg id --debug -r 3
   f6fc62dde3c0771e29704af56ba4d8af77abcc2f
   $ hg id --debug -r 4
   4efff6d98829d9c824c621afd6e3f01865f5439f
   $ hg id --debug -r 5
   c922c0139ca03858f655e4a2af4dd02796a63969 tip Y
   $ hg debugobsolete f6fc62dde3c0771e29704af56ba4d8af77abcc2f cccccccccccccccccccccccccccccccccccccccc
   1 new obsolescence markers
   obsoleted 1 changesets
   $ hg debugobsolete cccccccccccccccccccccccccccccccccccccccc 4efff6d98829d9c824c621afd6e3f01865f5439f
   1 new obsolescence markers
   $ hg push http://localhost:$HGPORT2/
   pushing to http://localhost:$HGPORT2/
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 2 changesets with 2 changes to 1 files (+1 heads)
   remote: 2 new obsolescence markers
   remote: obsoleted 1 changesets
   updating bookmark Y
   $ hg -R ../a book
      @                         1:0d2164f0ce0d
    * X                         1:0d2164f0ce0d
      Y                         5:c922c0139ca0
      Z                         1:0d2164f0ce0d
 
 hgweb
 
   $ cat <<EOF > .hg/hgrc
   > [web]
   > push_ssl = false
   > allow_push = *
   > EOF
 
   $ hg serve -p $HGPORT -d --pid-file=../hg.pid -E errors.log
   $ cat ../hg.pid >> $DAEMON_PIDS
   $ cd ../a
 
   $ hg debugpushkey http://localhost:$HGPORT/ namespaces
   bookmarks	
   namespaces	
   obsolete	
   phases	
   $ hg debugpushkey http://localhost:$HGPORT/ bookmarks
   @	9b140be1080824d768c5a4691a564088eede71f9
   X	9b140be1080824d768c5a4691a564088eede71f9
   Y	c922c0139ca03858f655e4a2af4dd02796a63969
   Z	9b140be1080824d768c5a4691a564088eede71f9
   foo	0000000000000000000000000000000000000000
   foobar	9b140be1080824d768c5a4691a564088eede71f9
   $ hg out -B http://localhost:$HGPORT/
   comparing with http://localhost:$HGPORT/
   searching for changed bookmarks
      @                         0d2164f0ce0d
      X                         0d2164f0ce0d
      Z                         0d2164f0ce0d
      foo                                   
      foobar                                
   $ hg push -B Z http://localhost:$HGPORT/
   pushing to http://localhost:$HGPORT/
   searching for changes
   no changes found
   updating bookmark Z
   [1]
   $ hg book -d Z
   $ hg in -B http://localhost:$HGPORT/
   comparing with http://localhost:$HGPORT/
   searching for changed bookmarks
      @                         9b140be10808
      X                         9b140be10808
      Z                         0d2164f0ce0d
      foo                       000000000000
      foobar                    9b140be10808
   $ hg pull -B Z http://localhost:$HGPORT/
   pulling from http://localhost:$HGPORT/
   no changes found
   divergent bookmark @ stored as @1
   divergent bookmark X stored as X@1
   adding remote bookmark Z
   adding remote bookmark foo
   adding remote bookmark foobar
   $ hg clone http://localhost:$HGPORT/ cloned-bookmarks
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 5 changesets with 5 changes to 3 files (+2 heads)
   2 new obsolescence markers
   new changesets 4e3505fd9583:c922c0139ca0 (5 drafts)
   updating to bookmark @
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R cloned-bookmarks bookmarks
    * @                         1:9b140be10808
      X                         1:9b140be10808
      Y                         4:c922c0139ca0
      Z                         2:0d2164f0ce0d
      foo                       -1:000000000000
      foobar                    1:9b140be10808
 
   $ cd ..
 
 Test to show result of bookmarks comparison
 
   $ mkdir bmcomparison
   $ cd bmcomparison
 
   $ hg init source
   $ hg -R source debugbuilddag '+2*2*3*4'
   $ hg -R source log -G --template '{rev}:{node|short}'
   o  4:e7bd5218ca15
   |
   | o  3:6100d3090acf
   |/
   | o  2:fa942426a6fd
   |/
   | o  1:66f7d451a68b
   |/
   o  0:1ea73414a91b
   
   $ hg -R source bookmarks -r 0 SAME
   $ hg -R source bookmarks -r 0 ADV_ON_REPO1
   $ hg -R source bookmarks -r 0 ADV_ON_REPO2
   $ hg -R source bookmarks -r 0 DIFF_ADV_ON_REPO1
   $ hg -R source bookmarks -r 0 DIFF_ADV_ON_REPO2
   $ hg -R source bookmarks -r 1 DIVERGED
 
   $ hg clone -U source repo1
 
 (test that incoming/outgoing exit with 1, if there is no bookmark to
 be exchanged)
 
   $ hg -R repo1 incoming -B
   comparing with $TESTTMP/bmcomparison/source
   searching for changed bookmarks
   no changed bookmarks found
   [1]
   $ hg -R repo1 outgoing -B
   comparing with $TESTTMP/bmcomparison/source
   searching for changed bookmarks
   no changed bookmarks found
   [1]
 
   $ hg -R repo1 bookmarks -f -r 1 ADD_ON_REPO1
   $ hg -R repo1 bookmarks -f -r 2 ADV_ON_REPO1
   $ hg -R repo1 bookmarks -f -r 3 DIFF_ADV_ON_REPO1
   $ hg -R repo1 bookmarks -f -r 3 DIFF_DIVERGED
   $ hg -R repo1 -q --config extensions.mq= strip 4
   $ hg -R repo1 log -G --template '{node|short} ({bookmarks})'
   o  6100d3090acf (DIFF_ADV_ON_REPO1 DIFF_DIVERGED)
   |
   | o  fa942426a6fd (ADV_ON_REPO1)
   |/
   | o  66f7d451a68b (ADD_ON_REPO1 DIVERGED)
   |/
   o  1ea73414a91b (ADV_ON_REPO2 DIFF_ADV_ON_REPO2 SAME)
   
 
   $ hg clone -U source repo2
   $ hg -R repo2 bookmarks -f -r 1 ADD_ON_REPO2
   $ hg -R repo2 bookmarks -f -r 1 ADV_ON_REPO2
   $ hg -R repo2 bookmarks -f -r 2 DIVERGED
   $ hg -R repo2 bookmarks -f -r 4 DIFF_ADV_ON_REPO2
   $ hg -R repo2 bookmarks -f -r 4 DIFF_DIVERGED
   $ hg -R repo2 -q --config extensions.mq= strip 3
   $ hg -R repo2 log -G --template '{node|short} ({bookmarks})'
   o  e7bd5218ca15 (DIFF_ADV_ON_REPO2 DIFF_DIVERGED)
   |
   | o  fa942426a6fd (DIVERGED)
   |/
   | o  66f7d451a68b (ADD_ON_REPO2 ADV_ON_REPO2)
   |/
   o  1ea73414a91b (ADV_ON_REPO1 DIFF_ADV_ON_REPO1 SAME)
   
 
 (test that difference of bookmarks between repositories are fully shown)
 
   $ hg -R repo1 incoming -B repo2 -v
   comparing with repo2
   searching for changed bookmarks
      ADD_ON_REPO2              66f7d451a68b added
      ADV_ON_REPO2              66f7d451a68b advanced
      DIFF_ADV_ON_REPO2         e7bd5218ca15 changed
      DIFF_DIVERGED             e7bd5218ca15 changed
      DIVERGED                  fa942426a6fd diverged
   $ hg -R repo1 outgoing -B repo2 -v
   comparing with repo2
   searching for changed bookmarks
      ADD_ON_REPO1              66f7d451a68b added
      ADD_ON_REPO2                           deleted
      ADV_ON_REPO1              fa942426a6fd advanced
      DIFF_ADV_ON_REPO1         6100d3090acf advanced
      DIFF_ADV_ON_REPO2         1ea73414a91b changed
      DIFF_DIVERGED             6100d3090acf changed
      DIVERGED                  66f7d451a68b diverged
 
   $ hg -R repo2 incoming -B repo1 -v
   comparing with repo1
   searching for changed bookmarks
      ADD_ON_REPO1              66f7d451a68b added
      ADV_ON_REPO1              fa942426a6fd advanced
      DIFF_ADV_ON_REPO1         6100d3090acf changed
      DIFF_DIVERGED             6100d3090acf changed
      DIVERGED                  66f7d451a68b diverged
   $ hg -R repo2 outgoing -B repo1 -v
   comparing with repo1
   searching for changed bookmarks
      ADD_ON_REPO1                           deleted
      ADD_ON_REPO2              66f7d451a68b added
      ADV_ON_REPO2              66f7d451a68b advanced
      DIFF_ADV_ON_REPO1         1ea73414a91b changed
      DIFF_ADV_ON_REPO2         e7bd5218ca15 advanced
      DIFF_DIVERGED             e7bd5218ca15 changed
      DIVERGED                  fa942426a6fd diverged
 
   $ cd ..
 
 Pushing a bookmark should only push the changes required by that
 bookmark, not all outgoing changes:
   $ hg clone http://localhost:$HGPORT/ addmarks
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 5 changesets with 5 changes to 3 files (+2 heads)
   2 new obsolescence markers
   new changesets 4e3505fd9583:c922c0139ca0 (5 drafts)
   updating to bookmark @
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd addmarks
   $ echo foo > foo
   $ hg add foo
   $ hg commit -m 'add foo'
   $ echo bar > bar
   $ hg add bar
   $ hg commit -m 'add bar'
   $ hg co "tip^"
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (leaving bookmark @)
   $ hg book add-foo
   $ hg book -r tip add-bar
 Note: this push *must* push only a single changeset, as that's the point
 of this test.
   $ hg push -B add-foo --traceback
   pushing to http://localhost:$HGPORT/
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 1 changesets with 1 changes to 1 files
   exporting bookmark add-foo
 
 pushing a new bookmark on a new head does not require -f if -B is specified
 
   $ hg up -q X
   $ hg book W
   $ echo c5 > f2
   $ hg ci -Am5
   created new head
   $ hg push -B .
   pushing to http://localhost:$HGPORT/
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 1 changesets with 1 changes to 1 files (+1 heads)
   exporting bookmark W
   $ hg -R ../b id -r W
   cc978a373a53 tip W
 
 pushing an existing but divergent bookmark with -B still requires -f
 
   $ hg clone -q . ../r
   $ hg up -q X
   $ echo 1 > f2
   $ hg ci -qAml
 
   $ cd ../r
   $ hg up -q X
   $ echo 2 > f2
   $ hg ci -qAmr
   $ hg push -B X
   pushing to $TESTTMP/addmarks
   searching for changes
   remote has heads on branch 'default' that are not known locally: a2a606d9ff1b
   abort: push creates new remote head 54694f811df9 with bookmark 'X'
   (pull and merge or see 'hg help push' for details about pushing new heads)
   [20]
   $ cd ../addmarks
 
 Check summary output for incoming/outgoing bookmarks
 
   $ hg bookmarks -d X
   $ hg bookmarks -d Y
   $ hg summary --remote | grep '^remote:'
   remote: *, 2 incoming bookmarks, 1 outgoing bookmarks (glob)
 
   $ cd ..
 
 pushing an unchanged bookmark should result in no changes
 
   $ hg init unchanged-a
   $ hg init unchanged-b
   $ cd unchanged-a
   $ echo initial > foo
   $ hg commit -A -m initial
   adding foo
   $ hg bookmark @
   $ hg push -B @ ../unchanged-b
   pushing to ../unchanged-b
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   exporting bookmark @
 
   $ hg push -B @ ../unchanged-b
   pushing to ../unchanged-b
   searching for changes
   no changes found
   [1]
 
 Pushing a really long bookmark should work fine (issue5165)
 ===============================================
 
 #if b2-binary
   >>> with open('longname', 'w') as f:
   ...     f.write('wat' * 100) and None
   $ hg book `cat longname`
   $ hg push -B `cat longname` ../unchanged-b
   pushing to ../unchanged-b
   searching for changes
   no changes found
   exporting bookmark (wat){100} (re)
   [1]
   $ hg -R ../unchanged-b book --delete `cat longname`
 
 Test again but forcing bundle2 exchange to make sure that doesn't regress.
 
   $ hg push -B `cat longname` ../unchanged-b --config devel.legacy.exchange=bundle1
   pushing to ../unchanged-b
   searching for changes
   no changes found
   exporting bookmark (wat){100} (re)
   [1]
   $ hg -R ../unchanged-b book --delete `cat longname`
   $ hg book --delete `cat longname`
   $ hg co @
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark @)
 #endif
 
 Check hook preventing push (issue4455)
 ======================================
 
   $ hg bookmarks
    * @                         0:55482a6fb4b1
   $ hg log -G
   @  0:55482a6fb4b1 initial
   
   $ hg init ../issue4455-dest
   $ hg push ../issue4455-dest # changesets only
   pushing to ../issue4455-dest
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   $ cat >> .hg/hgrc << EOF
   > [paths]
   > local=../issue4455-dest/
   > ssh=ssh://user@dummy/issue4455-dest
   > http=http://localhost:$HGPORT/
   > [ui]
   > ssh="$PYTHON" "$TESTDIR/dummyssh"
   > EOF
   $ cat >> ../issue4455-dest/.hg/hgrc << EOF
   > [hooks]
   > prepushkey=false
   > [web]
   > push_ssl = false
   > allow_push = *
   > EOF
   $ killdaemons.py
   $ hg serve -R ../issue4455-dest -p $HGPORT -d --pid-file=../issue4455.pid -E ../issue4455-error.log
   $ cat ../issue4455.pid >> $DAEMON_PIDS
 
 Local push
 ----------
 
 #if b2-pushkey
 
   $ hg push -B @ local
   pushing to $TESTTMP/issue4455-dest
   searching for changes
   no changes found
   pushkey-abort: prepushkey hook exited with status 1
   abort: exporting bookmark @ failed
   [255]
 
 #endif
 #if b2-binary
 
   $ hg push -B @ local
   pushing to $TESTTMP/issue4455-dest
   searching for changes
   no changes found
   abort: prepushkey hook exited with status 1
   [40]
 
 #endif
 
   $ hg -R ../issue4455-dest/ bookmarks
   no bookmarks set
 
 Using ssh
 ---------
 
 #if b2-pushkey
 
   $ hg push -B @ ssh # bundle2+
   pushing to ssh://user@dummy/issue4455-dest
   searching for changes
   no changes found
   remote: pushkey-abort: prepushkey hook exited with status 1
   abort: exporting bookmark @ failed
   [255]
 
   $ hg -R ../issue4455-dest/ bookmarks
   no bookmarks set
 
   $ hg push -B @ ssh --config devel.legacy.exchange=bundle1
   pushing to ssh://user@dummy/issue4455-dest
   searching for changes
   no changes found
   remote: pushkey-abort: prepushkey hook exited with status 1
   exporting bookmark @ failed
   [1]
 
 #endif
 #if b2-binary
 
   $ hg push -B @ ssh # bundle2+
   pushing to ssh://user@dummy/issue4455-dest
   searching for changes
   no changes found
   remote: prepushkey hook exited with status 1
   abort: push failed on remote
-  [255]
+  [100]
 
 #endif
 
   $ hg -R ../issue4455-dest/ bookmarks
   no bookmarks set
 
 Using http
 ----------
 
 #if b2-pushkey
   $ hg push -B @ http # bundle2+
   pushing to http://localhost:$HGPORT/
   searching for changes
   no changes found
   remote: pushkey-abort: prepushkey hook exited with status 1
   abort: exporting bookmark @ failed
   [255]
 
   $ hg -R ../issue4455-dest/ bookmarks
   no bookmarks set
 
   $ hg push -B @ http --config devel.legacy.exchange=bundle1
   pushing to http://localhost:$HGPORT/
   searching for changes
   no changes found
   remote: pushkey-abort: prepushkey hook exited with status 1
   exporting bookmark @ failed
   [1]
 
 #endif
 
 #if b2-binary
 
   $ hg push -B @ ssh # bundle2+
   pushing to ssh://user@dummy/issue4455-dest
   searching for changes
   no changes found
   remote: prepushkey hook exited with status 1
   abort: push failed on remote
-  [255]
+  [100]
 
 #endif
 
   $ hg -R ../issue4455-dest/ bookmarks
   no bookmarks set
 
   $ cd ..
 
 Test that pre-pushkey compat for bookmark works as expected (issue5777)
 
   $ cat << EOF >> $HGRCPATH
   > [ui]
   > ssh="$PYTHON" "$TESTDIR/dummyssh"
   > [server]
   > bookmarks-pushkey-compat = yes
   > EOF
 
   $ hg init server
   $ echo foo > server/a
   $ hg -R server book foo
   $ hg -R server commit -Am a
   adding a
   $ hg clone ssh://user@dummy/server client
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets 79513d0d7716 (1 drafts)
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Forbid bookmark move on the server
 
   $ cat << EOF >> $TESTTMP/no-bm-move.sh
   > #!/bin/sh
   > echo \$HG_NAMESPACE | grep -v bookmarks
   > EOF
   $ cat << EOF >> server/.hg/hgrc
   > [hooks]
   > prepushkey.no-bm-move= sh $TESTTMP/no-bm-move.sh
   > EOF
 
 pushing changeset is okay
 
   $ echo bar >> client/a
   $ hg -R client commit -m b
   $ hg -R client push
   pushing to ssh://user@dummy/server
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 1 changesets with 1 changes to 1 files
 
 attempt to move the bookmark is rejected
 
   $ hg -R client book foo -r .
   moving bookmark 'foo' forward from 79513d0d7716
 
 #if b2-pushkey
   $ hg -R client push
   pushing to ssh://user@dummy/server
   searching for changes
   no changes found
   remote: pushkey-abort: prepushkey.no-bm-move hook exited with status 1
   abort: updating bookmark foo failed
   [255]
 #endif
 #if b2-binary
   $ hg -R client push
   pushing to ssh://user@dummy/server
   searching for changes
   no changes found
   remote: prepushkey.no-bm-move hook exited with status 1
   abort: push failed on remote
-  [255]
+  [100]
 #endif
 
 -- test for pushing bookmarks pointing to secret changesets
 
 Set up a "remote" repo
   $ hg init issue6159remote
   $ cd issue6159remote
   $ echo a > a
   $ hg add a
   $ hg commit -m_
   $ hg bookmark foo
   $ cd ..
 
 Clone a local repo
   $ hg clone -q issue6159remote issue6159local
   $ cd issue6159local
   $ hg up -qr foo
   $ echo b > b
 
 Move the bookmark "foo" to point at a secret changeset
   $ hg commit -qAm_ --config phases.new-commit=secret
 
 Pushing the bookmark "foo" now fails as it contains a secret changeset
   $ hg push -r foo
   pushing to $TESTTMP/issue6159remote
   searching for changes
   no changes found (ignored 1 secret changesets)
   abort: cannot push bookmark foo as it points to a secret changeset
   [255]
 
 Test pushing all bookmarks
 
   $ hg init $TESTTMP/ab1
   $ cd $TESTTMP/ab1
   $ "$PYTHON" $TESTDIR/seq.py 1 5 | while read i; do
   > echo $i > test && hg ci -Am test
   > done
   adding test
   $ hg clone -U . ../ab2
   $ hg book -r 1 A; hg book -r 2 B; hg book -r 3 C
   $ hg push ../ab2
   pushing to ../ab2
   searching for changes
   no changes found
   [1]
   $ hg push --all-bookmarks -r 1 ../ab2
   abort: cannot specify both --all-bookmarks and --rev
   [10]
   $ hg push --all-bookmarks -B A ../ab2
   abort: cannot specify both --all-bookmarks and --bookmark
   [10]
   $ hg push --all-bookmarks ../ab2
   pushing to ../ab2
   searching for changes
   no changes found
   exporting bookmark A
   exporting bookmark B
   exporting bookmark C
   [1]

tests/test-bundle2-exchange.t

@@ -1,1152 +1,1152 b''
 #testcases sshv1 sshv2
 
 #if sshv2
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > sshpeer.advertise-v2 = true
   > sshserver.support-v2 = true
   > EOF
 #endif
 
 Test exchange of common information using bundle2
 
 
   $ getmainid() {
   >    hg -R main log --template '{node}\n' --rev "$1"
   > }
 
 enable obsolescence
 
   $ cp $HGRCPATH $TESTTMP/hgrc.orig
   $ cat > $TESTTMP/bundle2-pushkey-hook.sh << EOF
   > echo pushkey: lock state after \"\$HG_NAMESPACE\"
   > hg debuglock
   > EOF
 
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > evolution.createmarkers=True
   > evolution.exchange=True
   > bundle2-output-capture=True
   > [ui]
   > ssh="$PYTHON" "$TESTDIR/dummyssh"
   > [command-templates]
   > log={rev}:{node|short} {phase} {author} {bookmarks} {desc|firstline}
   > [web]
   > push_ssl = false
   > allow_push = *
   > [phases]
   > publish=False
   > [hooks]
   > pretxnclose.tip = hg log -r tip -T "pre-close-tip:{node|short} {phase} {bookmarks}\n"
   > txnclose.tip = hg log -r tip -T "postclose-tip:{node|short} {phase} {bookmarks}\n"
   > txnclose.env = sh -c  "HG_LOCAL= printenv.py txnclose"
   > pushkey= sh "$TESTTMP/bundle2-pushkey-hook.sh"
   > EOF
 
 The extension requires a repo (currently unused)
 
   $ hg init main
   $ cd main
   $ touch a
   $ hg add a
   $ hg commit -m 'a'
   pre-close-tip:3903775176ed draft 
   postclose-tip:3903775176ed draft 
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_PHASES_MOVED=1 HG_TXNID=TXN:$ID$ HG_TXNNAME=commit
 
   $ hg unbundle $TESTDIR/bundles/rebase.hg
   adding changesets
   adding manifests
   adding file changes
   pre-close-tip:02de42196ebe draft 
   added 8 changesets with 7 changes to 7 files (+3 heads)
   new changesets cd010b8cd998:02de42196ebe (8 drafts)
   postclose-tip:02de42196ebe draft 
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_NODE=cd010b8cd998f3981a5a8115f94f8da4ab506089 HG_NODE_LAST=02de42196ebee42ef284b6780a87cdc96e8eaab6 HG_PHASES_MOVED=1 HG_SOURCE=unbundle HG_TXNID=TXN:$ID$ HG_TXNNAME=unbundle
   bundle:*/tests/bundles/rebase.hg HG_URL=bundle:*/tests/bundles/rebase.hg (glob)
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
   $ cd ..
 
 Real world exchange
 =====================
 
 Add more obsolescence information
 
   $ hg -R main debugobsolete -d '0 0' 1111111111111111111111111111111111111111 `getmainid 9520eea781bc`
   pre-close-tip:02de42196ebe draft 
   1 new obsolescence markers
   postclose-tip:02de42196ebe draft 
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_NEW_OBSMARKERS=1 HG_TXNID=TXN:$ID$ HG_TXNNAME=debugobsolete
   $ hg -R main debugobsolete -d '0 0' 2222222222222222222222222222222222222222 `getmainid 24b6387c8c8c`
   pre-close-tip:02de42196ebe draft 
   1 new obsolescence markers
   postclose-tip:02de42196ebe draft 
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_NEW_OBSMARKERS=1 HG_TXNID=TXN:$ID$ HG_TXNNAME=debugobsolete
 
 clone --pull
 
   $ hg -R main phase --public cd010b8cd998
   pre-close-tip:02de42196ebe draft 
   postclose-tip:02de42196ebe draft 
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_PHASES_MOVED=1 HG_TXNID=TXN:$ID$ HG_TXNNAME=phase
   $ hg clone main other --pull --rev 9520eea781bc
   adding changesets
   adding manifests
   adding file changes
   pre-close-tip:9520eea781bc draft 
   added 2 changesets with 2 changes to 2 files
   1 new obsolescence markers
   new changesets cd010b8cd998:9520eea781bc (1 drafts)
   postclose-tip:9520eea781bc draft 
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_NEW_OBSMARKERS=1 HG_NODE=cd010b8cd998f3981a5a8115f94f8da4ab506089 HG_NODE_LAST=9520eea781bcca16c1e15acc0ba14335a0e8e5ba HG_PHASES_MOVED=1 HG_SOURCE=pull HG_TXNID=TXN:$ID$ HG_TXNNAME=pull
   file:/*/$TESTTMP/main HG_URL=file:$TESTTMP/main (glob)
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R other log -G
   @  1:9520eea781bc draft Nicolas Dumazet <[e-mail]>  E
   |
   o  0:cd010b8cd998 public Nicolas Dumazet <[e-mail]>  A
   
   $ hg -R other debugobsolete
   1111111111111111111111111111111111111111 9520eea781bcca16c1e15acc0ba14335a0e8e5ba 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
 
 pull
 
   $ hg -R main phase --public 9520eea781bc
   pre-close-tip:02de42196ebe draft 
   postclose-tip:02de42196ebe draft 
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_PHASES_MOVED=1 HG_TXNID=TXN:$ID$ HG_TXNNAME=phase
   $ hg -R other pull -r 24b6387c8c8c
   pulling from $TESTTMP/main
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   pre-close-tip:24b6387c8c8c draft 
   added 1 changesets with 1 changes to 1 files (+1 heads)
   1 new obsolescence markers
   new changesets 24b6387c8c8c (1 drafts)
   postclose-tip:24b6387c8c8c draft 
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_NEW_OBSMARKERS=1 HG_NODE=24b6387c8c8cae37178880f3fa95ded3cb1cf785 HG_NODE_LAST=24b6387c8c8cae37178880f3fa95ded3cb1cf785 HG_PHASES_MOVED=1 HG_SOURCE=pull HG_TXNID=TXN:$ID$ HG_TXNNAME=pull
   file:/*/$TESTTMP/main HG_URL=file:$TESTTMP/main (glob)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg -R other log -G
   o  2:24b6387c8c8c draft Nicolas Dumazet <[e-mail]>  F
   |
   | @  1:9520eea781bc draft Nicolas Dumazet <[e-mail]>  E
   |/
   o  0:cd010b8cd998 public Nicolas Dumazet <[e-mail]>  A
   
   $ hg -R other debugobsolete
   1111111111111111111111111111111111111111 9520eea781bcca16c1e15acc0ba14335a0e8e5ba 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   2222222222222222222222222222222222222222 24b6387c8c8cae37178880f3fa95ded3cb1cf785 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
 
 pull empty (with phase movement)
 
   $ hg -R main phase --public 24b6387c8c8c
   pre-close-tip:02de42196ebe draft 
   postclose-tip:02de42196ebe draft 
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_PHASES_MOVED=1 HG_TXNID=TXN:$ID$ HG_TXNNAME=phase
   $ hg -R other pull -r 24b6387c8c8c
   pulling from $TESTTMP/main
   no changes found
   pre-close-tip:24b6387c8c8c public 
   1 local changesets published
   postclose-tip:24b6387c8c8c public 
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_NEW_OBSMARKERS=0 HG_PHASES_MOVED=1 HG_SOURCE=pull HG_TXNID=TXN:$ID$ HG_TXNNAME=pull
   file:/*/$TESTTMP/main HG_URL=file:$TESTTMP/main (glob)
   $ hg -R other log -G
   o  2:24b6387c8c8c public Nicolas Dumazet <[e-mail]>  F
   |
   | @  1:9520eea781bc draft Nicolas Dumazet <[e-mail]>  E
   |/
   o  0:cd010b8cd998 public Nicolas Dumazet <[e-mail]>  A
   
   $ hg -R other debugobsolete
   1111111111111111111111111111111111111111 9520eea781bcca16c1e15acc0ba14335a0e8e5ba 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   2222222222222222222222222222222222222222 24b6387c8c8cae37178880f3fa95ded3cb1cf785 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
 
 pull empty
 
   $ hg -R other pull -r 24b6387c8c8c
   pulling from $TESTTMP/main
   no changes found
   pre-close-tip:24b6387c8c8c public 
   postclose-tip:24b6387c8c8c public 
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_NEW_OBSMARKERS=0 HG_SOURCE=pull HG_TXNID=TXN:$ID$ HG_TXNNAME=pull
   file:/*/$TESTTMP/main HG_URL=file:$TESTTMP/main (glob)
   $ hg -R other log -G
   o  2:24b6387c8c8c public Nicolas Dumazet <[e-mail]>  F
   |
   | @  1:9520eea781bc draft Nicolas Dumazet <[e-mail]>  E
   |/
   o  0:cd010b8cd998 public Nicolas Dumazet <[e-mail]>  A
   
   $ hg -R other debugobsolete
   1111111111111111111111111111111111111111 9520eea781bcca16c1e15acc0ba14335a0e8e5ba 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   2222222222222222222222222222222222222222 24b6387c8c8cae37178880f3fa95ded3cb1cf785 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
 
 add extra data to test their exchange during push
 
   $ hg -R main bookmark --rev eea13746799a book_eea1
   pre-close-tip:02de42196ebe draft 
   postclose-tip:02de42196ebe draft 
   txnclose hook: HG_BOOKMARK_MOVED=1 HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_TXNID=TXN:$ID$ HG_TXNNAME=bookmark
   $ hg -R main debugobsolete -d '0 0' 3333333333333333333333333333333333333333 `getmainid eea13746799a`
   pre-close-tip:02de42196ebe draft 
   1 new obsolescence markers
   postclose-tip:02de42196ebe draft 
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_NEW_OBSMARKERS=1 HG_TXNID=TXN:$ID$ HG_TXNNAME=debugobsolete
   $ hg -R main bookmark --rev 02de42196ebe book_02de
   pre-close-tip:02de42196ebe draft book_02de
   postclose-tip:02de42196ebe draft book_02de
   txnclose hook: HG_BOOKMARK_MOVED=1 HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_TXNID=TXN:$ID$ HG_TXNNAME=bookmark
   $ hg -R main debugobsolete -d '0 0' 4444444444444444444444444444444444444444 `getmainid 02de42196ebe`
   pre-close-tip:02de42196ebe draft book_02de
   1 new obsolescence markers
   postclose-tip:02de42196ebe draft book_02de
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_NEW_OBSMARKERS=1 HG_TXNID=TXN:$ID$ HG_TXNNAME=debugobsolete
   $ hg -R main bookmark --rev 42ccdea3bb16 book_42cc
   pre-close-tip:02de42196ebe draft book_02de
   postclose-tip:02de42196ebe draft book_02de
   txnclose hook: HG_BOOKMARK_MOVED=1 HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_TXNID=TXN:$ID$ HG_TXNNAME=bookmark
   $ hg -R main debugobsolete -d '0 0' 5555555555555555555555555555555555555555 `getmainid 42ccdea3bb16`
   pre-close-tip:02de42196ebe draft book_02de
   1 new obsolescence markers
   postclose-tip:02de42196ebe draft book_02de
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_NEW_OBSMARKERS=1 HG_TXNID=TXN:$ID$ HG_TXNNAME=debugobsolete
   $ hg -R main bookmark --rev 5fddd98957c8 book_5fdd
   pre-close-tip:02de42196ebe draft book_02de
   postclose-tip:02de42196ebe draft book_02de
   txnclose hook: HG_BOOKMARK_MOVED=1 HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_TXNID=TXN:$ID$ HG_TXNNAME=bookmark
   $ hg -R main debugobsolete -d '0 0' 6666666666666666666666666666666666666666 `getmainid 5fddd98957c8`
   pre-close-tip:02de42196ebe draft book_02de
   1 new obsolescence markers
   postclose-tip:02de42196ebe draft book_02de
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_NEW_OBSMARKERS=1 HG_TXNID=TXN:$ID$ HG_TXNNAME=debugobsolete
   $ hg -R main bookmark --rev 32af7686d403 book_32af
   pre-close-tip:02de42196ebe draft book_02de
   postclose-tip:02de42196ebe draft book_02de
   txnclose hook: HG_BOOKMARK_MOVED=1 HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_TXNID=TXN:$ID$ HG_TXNNAME=bookmark
   $ hg -R main debugobsolete -d '0 0' 7777777777777777777777777777777777777777 `getmainid 32af7686d403`
   pre-close-tip:02de42196ebe draft book_02de
   1 new obsolescence markers
   postclose-tip:02de42196ebe draft book_02de
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_NEW_OBSMARKERS=1 HG_TXNID=TXN:$ID$ HG_TXNNAME=debugobsolete
 
   $ hg -R other bookmark --rev cd010b8cd998 book_eea1
   pre-close-tip:24b6387c8c8c public 
   postclose-tip:24b6387c8c8c public 
   txnclose hook: HG_BOOKMARK_MOVED=1 HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_TXNID=TXN:$ID$ HG_TXNNAME=bookmark
   $ hg -R other bookmark --rev cd010b8cd998 book_02de
   pre-close-tip:24b6387c8c8c public 
   postclose-tip:24b6387c8c8c public 
   txnclose hook: HG_BOOKMARK_MOVED=1 HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_TXNID=TXN:$ID$ HG_TXNNAME=bookmark
   $ hg -R other bookmark --rev cd010b8cd998 book_42cc
   pre-close-tip:24b6387c8c8c public 
   postclose-tip:24b6387c8c8c public 
   txnclose hook: HG_BOOKMARK_MOVED=1 HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_TXNID=TXN:$ID$ HG_TXNNAME=bookmark
   $ hg -R other bookmark --rev cd010b8cd998 book_5fdd
   pre-close-tip:24b6387c8c8c public 
   postclose-tip:24b6387c8c8c public 
   txnclose hook: HG_BOOKMARK_MOVED=1 HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_TXNID=TXN:$ID$ HG_TXNNAME=bookmark
   $ hg -R other bookmark --rev cd010b8cd998 book_32af
   pre-close-tip:24b6387c8c8c public 
   postclose-tip:24b6387c8c8c public 
   txnclose hook: HG_BOOKMARK_MOVED=1 HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_TXNID=TXN:$ID$ HG_TXNNAME=bookmark
 
   $ hg -R main phase --public eea13746799a
   pre-close-tip:02de42196ebe draft book_02de
   postclose-tip:02de42196ebe draft book_02de
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_PHASES_MOVED=1 HG_TXNID=TXN:$ID$ HG_TXNNAME=phase
 
 push
   $ hg -R main push other --rev eea13746799a --bookmark book_eea1
   pushing to other
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: pre-close-tip:eea13746799a public book_eea1
   remote: added 1 changesets with 0 changes to 0 files (-1 heads)
   remote: 1 new obsolescence markers
   remote: pushkey: lock state after "bookmarks"
   remote: lock:  free
   remote: wlock: free
   remote: postclose-tip:eea13746799a public book_eea1
   remote: txnclose hook: HG_BOOKMARK_MOVED=1 HG_BUNDLE2=1 HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_NEW_OBSMARKERS=1 HG_NODE=eea13746799a9e0bfd88f29d3c2e9dc9389f524f HG_NODE_LAST=eea13746799a9e0bfd88f29d3c2e9dc9389f524f HG_PHASES_MOVED=1 HG_SOURCE=push HG_TXNID=TXN:$ID$ HG_TXNNAME=push HG_URL=file:$TESTTMP/other
   updating bookmark book_eea1
   pre-close-tip:02de42196ebe draft book_02de
   postclose-tip:02de42196ebe draft book_02de
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_SOURCE=push-response HG_TXNID=TXN:$ID$ HG_TXNNAME=push-response
   file:/*/$TESTTMP/other HG_URL=file:$TESTTMP/other (glob)
   $ hg -R other log -G
   o    3:eea13746799a public Nicolas Dumazet <[e-mail]> book_eea1 G
   |\
   | o  2:24b6387c8c8c public Nicolas Dumazet <[e-mail]>  F
   | |
   @ |  1:9520eea781bc public Nicolas Dumazet <[e-mail]>  E
   |/
   o  0:cd010b8cd998 public Nicolas Dumazet <[e-mail]> book_02de book_32af book_42cc book_5fdd A
   
   $ hg -R other debugobsolete
   1111111111111111111111111111111111111111 9520eea781bcca16c1e15acc0ba14335a0e8e5ba 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   2222222222222222222222222222222222222222 24b6387c8c8cae37178880f3fa95ded3cb1cf785 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   3333333333333333333333333333333333333333 eea13746799a9e0bfd88f29d3c2e9dc9389f524f 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
 
 pull over ssh
 
   $ hg -R other pull ssh://user@dummy/main -r 02de42196ebe --bookmark book_02de
   pulling from ssh://user@dummy/main
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   updating bookmark book_02de
   pre-close-tip:02de42196ebe draft book_02de
   added 1 changesets with 1 changes to 1 files (+1 heads)
   1 new obsolescence markers
   new changesets 02de42196ebe (1 drafts)
   postclose-tip:02de42196ebe draft book_02de
   txnclose hook: HG_BOOKMARK_MOVED=1 HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_NEW_OBSMARKERS=1 HG_NODE=02de42196ebee42ef284b6780a87cdc96e8eaab6 HG_NODE_LAST=02de42196ebee42ef284b6780a87cdc96e8eaab6 HG_PHASES_MOVED=1 HG_SOURCE=pull HG_TXNID=TXN:$ID$ HG_TXNNAME=pull
   ssh://user@dummy/main HG_URL=ssh://user@dummy/main
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg -R other debugobsolete
   1111111111111111111111111111111111111111 9520eea781bcca16c1e15acc0ba14335a0e8e5ba 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   2222222222222222222222222222222222222222 24b6387c8c8cae37178880f3fa95ded3cb1cf785 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   3333333333333333333333333333333333333333 eea13746799a9e0bfd88f29d3c2e9dc9389f524f 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   4444444444444444444444444444444444444444 02de42196ebee42ef284b6780a87cdc96e8eaab6 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
 
 pull over http
 
   $ hg serve -R main -p $HGPORT -d --pid-file=main.pid -E main-error.log
   $ cat main.pid >> $DAEMON_PIDS
 
   $ hg -R other pull http://localhost:$HGPORT/ -r 42ccdea3bb16 --bookmark book_42cc
   pulling from http://localhost:$HGPORT/
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   updating bookmark book_42cc
   pre-close-tip:42ccdea3bb16 draft book_42cc
   added 1 changesets with 1 changes to 1 files (+1 heads)
   1 new obsolescence markers
   new changesets 42ccdea3bb16 (1 drafts)
   postclose-tip:42ccdea3bb16 draft book_42cc
   txnclose hook: HG_BOOKMARK_MOVED=1 HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_NEW_OBSMARKERS=1 HG_NODE=42ccdea3bb16d28e1848c95fe2e44c000f3f21b1 HG_NODE_LAST=42ccdea3bb16d28e1848c95fe2e44c000f3f21b1 HG_PHASES_MOVED=1 HG_SOURCE=pull HG_TXNID=TXN:$ID$ HG_TXNNAME=pull
   http://localhost:$HGPORT/ HG_URL=http://localhost:$HGPORT/
   (run 'hg heads .' to see heads, 'hg merge' to merge)
   $ cat main-error.log
   $ hg -R other debugobsolete
   1111111111111111111111111111111111111111 9520eea781bcca16c1e15acc0ba14335a0e8e5ba 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   2222222222222222222222222222222222222222 24b6387c8c8cae37178880f3fa95ded3cb1cf785 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   3333333333333333333333333333333333333333 eea13746799a9e0bfd88f29d3c2e9dc9389f524f 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   4444444444444444444444444444444444444444 02de42196ebee42ef284b6780a87cdc96e8eaab6 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   5555555555555555555555555555555555555555 42ccdea3bb16d28e1848c95fe2e44c000f3f21b1 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
 
 push over ssh
 
   $ hg -R main push ssh://user@dummy/other -r 5fddd98957c8 --bookmark book_5fdd
   pushing to ssh://user@dummy/other
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: pre-close-tip:5fddd98957c8 draft book_5fdd
   remote: added 1 changesets with 1 changes to 1 files
   remote: 1 new obsolescence markers
   remote: pushkey: lock state after "bookmarks"
   remote: lock:  free
   remote: wlock: free
   remote: postclose-tip:5fddd98957c8 draft book_5fdd
   remote: txnclose hook: HG_BOOKMARK_MOVED=1 HG_BUNDLE2=1 HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_NEW_OBSMARKERS=1 HG_NODE=5fddd98957c8a54a4d436dfe1da9d87f21a1b97b HG_NODE_LAST=5fddd98957c8a54a4d436dfe1da9d87f21a1b97b HG_SOURCE=serve HG_TXNID=TXN:$ID$ HG_TXNNAME=serve HG_URL=remote:ssh:$LOCALIP
   updating bookmark book_5fdd
   pre-close-tip:02de42196ebe draft book_02de
   postclose-tip:02de42196ebe draft book_02de
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_SOURCE=push-response HG_TXNID=TXN:$ID$ HG_TXNNAME=push-response
   ssh://user@dummy/other HG_URL=ssh://user@dummy/other
   $ hg -R other log -G
   o  6:5fddd98957c8 draft Nicolas Dumazet <[e-mail]> book_5fdd C
   |
   o  5:42ccdea3bb16 draft Nicolas Dumazet <[e-mail]> book_42cc B
   |
   | o  4:02de42196ebe draft Nicolas Dumazet <[e-mail]> book_02de H
   | |
   | | o  3:eea13746799a public Nicolas Dumazet <[e-mail]> book_eea1 G
   | |/|
   | o |  2:24b6387c8c8c public Nicolas Dumazet <[e-mail]>  F
   |/ /
   | @  1:9520eea781bc public Nicolas Dumazet <[e-mail]>  E
   |/
   o  0:cd010b8cd998 public Nicolas Dumazet <[e-mail]> book_32af A
   
   $ hg -R other debugobsolete
   1111111111111111111111111111111111111111 9520eea781bcca16c1e15acc0ba14335a0e8e5ba 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   2222222222222222222222222222222222222222 24b6387c8c8cae37178880f3fa95ded3cb1cf785 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   3333333333333333333333333333333333333333 eea13746799a9e0bfd88f29d3c2e9dc9389f524f 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   4444444444444444444444444444444444444444 02de42196ebee42ef284b6780a87cdc96e8eaab6 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   5555555555555555555555555555555555555555 42ccdea3bb16d28e1848c95fe2e44c000f3f21b1 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   6666666666666666666666666666666666666666 5fddd98957c8a54a4d436dfe1da9d87f21a1b97b 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
 
 push over http
 
   $ hg serve -R other -p $HGPORT2 -d --pid-file=other.pid -E other-error.log
   $ cat other.pid >> $DAEMON_PIDS
 
   $ hg -R main phase --public 32af7686d403
   pre-close-tip:02de42196ebe draft book_02de
   postclose-tip:02de42196ebe draft book_02de
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_PHASES_MOVED=1 HG_TXNID=TXN:$ID$ HG_TXNNAME=phase
   $ hg -R main push http://localhost:$HGPORT2/ -r 32af7686d403 --bookmark book_32af
   pushing to http://localhost:$HGPORT2/
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: pre-close-tip:32af7686d403 public book_32af
   remote: added 1 changesets with 1 changes to 1 files
   remote: 1 new obsolescence markers
   remote: pushkey: lock state after "bookmarks"
   remote: lock:  free
   remote: wlock: free
   remote: postclose-tip:32af7686d403 public book_32af
   remote: txnclose hook: HG_BOOKMARK_MOVED=1 HG_BUNDLE2=1 HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_NEW_OBSMARKERS=1 HG_NODE=32af7686d403cf45b5d95f2d70cebea587ac806a HG_NODE_LAST=32af7686d403cf45b5d95f2d70cebea587ac806a HG_PHASES_MOVED=1 HG_SOURCE=serve HG_TXNID=TXN:$ID$ HG_TXNNAME=serve HG_URL=remote:http:$LOCALIP: (glob)
   updating bookmark book_32af
   pre-close-tip:02de42196ebe draft book_02de
   postclose-tip:02de42196ebe draft book_02de
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_SOURCE=push-response HG_TXNID=TXN:$ID$ HG_TXNNAME=push-response
   http://localhost:$HGPORT2/ HG_URL=http://localhost:$HGPORT2/
   $ cat other-error.log
 
 Check final content.
 
   $ hg -R other log -G
   o  7:32af7686d403 public Nicolas Dumazet <[e-mail]> book_32af D
   |
   o  6:5fddd98957c8 public Nicolas Dumazet <[e-mail]> book_5fdd C
   |
   o  5:42ccdea3bb16 public Nicolas Dumazet <[e-mail]> book_42cc B
   |
   | o  4:02de42196ebe draft Nicolas Dumazet <[e-mail]> book_02de H
   | |
   | | o  3:eea13746799a public Nicolas Dumazet <[e-mail]> book_eea1 G
   | |/|
   | o |  2:24b6387c8c8c public Nicolas Dumazet <[e-mail]>  F
   |/ /
   | @  1:9520eea781bc public Nicolas Dumazet <[e-mail]>  E
   |/
   o  0:cd010b8cd998 public Nicolas Dumazet <[e-mail]>  A
   
   $ hg -R other debugobsolete
   1111111111111111111111111111111111111111 9520eea781bcca16c1e15acc0ba14335a0e8e5ba 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   2222222222222222222222222222222222222222 24b6387c8c8cae37178880f3fa95ded3cb1cf785 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   3333333333333333333333333333333333333333 eea13746799a9e0bfd88f29d3c2e9dc9389f524f 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   4444444444444444444444444444444444444444 02de42196ebee42ef284b6780a87cdc96e8eaab6 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   5555555555555555555555555555555555555555 42ccdea3bb16d28e1848c95fe2e44c000f3f21b1 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   6666666666666666666666666666666666666666 5fddd98957c8a54a4d436dfe1da9d87f21a1b97b 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
   7777777777777777777777777777777777777777 32af7686d403cf45b5d95f2d70cebea587ac806a 0 (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
 
 (check that no 'pending' files remain)
 
   $ ls -1 other/.hg/bookmarks*
   other/.hg/bookmarks
   $ ls -1 other/.hg/store/phaseroots*
   other/.hg/store/phaseroots
   $ ls -1 other/.hg/store/00changelog.i*
   other/.hg/store/00changelog.i
 
 Error Handling
 ==============
 
 Check that errors are properly returned to the client during push.
 
 Setting up
 
   $ cat > failpush.py << EOF
   > """A small extension that makes push fails when using bundle2
   > 
   > used to test error handling in bundle2
   > """
   > 
   > from mercurial import error
   > from mercurial import bundle2
   > from mercurial import exchange
   > from mercurial import extensions
   > from mercurial import registrar
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > 
   > configtable = {}
   > configitem = registrar.configitem(configtable)
   > configitem(b'failpush', b'reason',
   >     default=None,
   > )
   > 
   > def _pushbundle2failpart(pushop, bundler):
   >     reason = pushop.ui.config(b'failpush', b'reason')
   >     part = None
   >     if reason == b'abort':
   >         bundler.newpart(b'test:abort')
   >     if reason == b'unknown':
   >         bundler.newpart(b'test:unknown')
   >     if reason == b'race':
   >         # 20 Bytes of crap
   >         bundler.newpart(b'check:heads', data=b'01234567890123456789')
   > 
   > @bundle2.parthandler(b"test:abort")
   > def handleabort(op, part):
   >     raise error.Abort(b'Abandon ship!', hint=b"don't panic")
   > 
   > def uisetup(ui):
   >     exchange.b2partsgenmapping[b'failpart'] = _pushbundle2failpart
   >     exchange.b2partsgenorder.insert(0, b'failpart')
   > 
   > EOF
 
   $ cd main
   $ hg up tip
   3 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo 'I' > I
   $ hg add I
   $ hg ci -m 'I'
   pre-close-tip:e7ec4e813ba6 draft 
   postclose-tip:e7ec4e813ba6 draft 
   txnclose hook: HG_HOOKNAME=txnclose.env HG_HOOKTYPE=txnclose HG_TXNID=TXN:$ID$ HG_TXNNAME=commit
   $ hg id
   e7ec4e813ba6 tip
   $ cd ..
 
   $ cat << EOF >> $HGRCPATH
   > [extensions]
   > failpush=$TESTTMP/failpush.py
   > EOF
 
   $ killdaemons.py
   $ hg serve -R other -p $HGPORT2 -d --pid-file=other.pid -E other-error.log
   $ cat other.pid >> $DAEMON_PIDS
 
 Doing the actual push: Abort error
 
   $ cat << EOF >> $HGRCPATH
   > [failpush]
   > reason = abort
   > EOF
 
   $ hg -R main push other -r e7ec4e813ba6
   pushing to other
   searching for changes
   abort: Abandon ship!
   (don't panic)
   [255]
 
   $ hg -R main push ssh://user@dummy/other -r e7ec4e813ba6
   pushing to ssh://user@dummy/other
   searching for changes
   remote: Abandon ship!
   remote: (don't panic)
   abort: push failed on remote
-  [255]
+  [100]
 
   $ hg -R main push http://localhost:$HGPORT2/ -r e7ec4e813ba6
   pushing to http://localhost:$HGPORT2/
   searching for changes
   remote: Abandon ship!
   remote: (don't panic)
   abort: push failed on remote
-  [255]
+  [100]
 
 
 Doing the actual push: unknown mandatory parts
 
   $ cat << EOF >> $HGRCPATH
   > [failpush]
   > reason = unknown
   > EOF
 
   $ hg -R main push other -r e7ec4e813ba6
   pushing to other
   searching for changes
   abort: missing support for test:unknown
-  [255]
+  [100]
 
   $ hg -R main push ssh://user@dummy/other -r e7ec4e813ba6
   pushing to ssh://user@dummy/other
   searching for changes
   abort: missing support for test:unknown
-  [255]
+  [100]
 
   $ hg -R main push http://localhost:$HGPORT2/ -r e7ec4e813ba6
   pushing to http://localhost:$HGPORT2/
   searching for changes
   abort: missing support for test:unknown
-  [255]
+  [100]
 
 Doing the actual push: race
 
   $ cat << EOF >> $HGRCPATH
   > [failpush]
   > reason = race
   > EOF
 
   $ hg -R main push other -r e7ec4e813ba6
   pushing to other
   searching for changes
   abort: push failed:
   'remote repository changed while pushing - please try again'
   [255]
 
   $ hg -R main push ssh://user@dummy/other -r e7ec4e813ba6
   pushing to ssh://user@dummy/other
   searching for changes
   abort: push failed:
   'remote repository changed while pushing - please try again'
   [255]
 
   $ hg -R main push http://localhost:$HGPORT2/ -r e7ec4e813ba6
   pushing to http://localhost:$HGPORT2/
   searching for changes
   abort: push failed:
   'remote repository changed while pushing - please try again'
   [255]
 
 Doing the actual push: hook abort
 
   $ cat << EOF >> $HGRCPATH
   > [failpush]
   > reason =
   > [hooks]
   > pretxnclose.failpush = sh -c "echo 'You shall not pass!'; false"
   > txnabort.failpush = sh -c "echo 'Cleaning up the mess...'"
   > EOF
 
   $ killdaemons.py
   $ hg serve -R other -p $HGPORT2 -d --pid-file=other.pid -E other-error.log
   $ cat other.pid >> $DAEMON_PIDS
 
   $ hg -R main push other -r e7ec4e813ba6
   pushing to other
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: pre-close-tip:e7ec4e813ba6 draft 
   remote: You shall not pass!
   remote: transaction abort!
   remote: Cleaning up the mess...
   remote: rollback completed
   abort: pretxnclose.failpush hook exited with status 1
   [40]
 
   $ hg -R main push ssh://user@dummy/other -r e7ec4e813ba6
   pushing to ssh://user@dummy/other
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: pre-close-tip:e7ec4e813ba6 draft 
   remote: You shall not pass!
   remote: transaction abort!
   remote: Cleaning up the mess...
   remote: rollback completed
   remote: pretxnclose.failpush hook exited with status 1
   abort: push failed on remote
-  [255]
+  [100]
 
   $ hg -R main push http://localhost:$HGPORT2/ -r e7ec4e813ba6
   pushing to http://localhost:$HGPORT2/
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: pre-close-tip:e7ec4e813ba6 draft 
   remote: You shall not pass!
   remote: transaction abort!
   remote: Cleaning up the mess...
   remote: rollback completed
   remote: pretxnclose.failpush hook exited with status 1
   abort: push failed on remote
-  [255]
+  [100]
 
 (check that no 'pending' files remain)
 
   $ ls -1 other/.hg/bookmarks*
   other/.hg/bookmarks
   $ ls -1 other/.hg/store/phaseroots*
   other/.hg/store/phaseroots
   $ ls -1 other/.hg/store/00changelog.i*
   other/.hg/store/00changelog.i
 
 Check error from hook during the unbundling process itself
 
   $ cat << EOF >> $HGRCPATH
   > pretxnchangegroup = sh -c "echo 'Fail early!'; false"
   > EOF
   $ killdaemons.py # reload http config
   $ hg serve -R other -p $HGPORT2 -d --pid-file=other.pid -E other-error.log
   $ cat other.pid >> $DAEMON_PIDS
 
   $ hg -R main push other -r e7ec4e813ba6
   pushing to other
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: Fail early!
   remote: transaction abort!
   remote: Cleaning up the mess...
   remote: rollback completed
   abort: pretxnchangegroup hook exited with status 1
   [40]
   $ hg -R main push ssh://user@dummy/other -r e7ec4e813ba6
   pushing to ssh://user@dummy/other
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: Fail early!
   remote: transaction abort!
   remote: Cleaning up the mess...
   remote: rollback completed
   remote: pretxnchangegroup hook exited with status 1
   abort: push failed on remote
-  [255]
+  [100]
   $ hg -R main push http://localhost:$HGPORT2/ -r e7ec4e813ba6
   pushing to http://localhost:$HGPORT2/
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: Fail early!
   remote: transaction abort!
   remote: Cleaning up the mess...
   remote: rollback completed
   remote: pretxnchangegroup hook exited with status 1
   abort: push failed on remote
-  [255]
+  [100]
 
 Check output capture control.
 
 (should be still forced for http, disabled for local and ssh)
 
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > bundle2-output-capture=False
   > EOF
 
   $ hg -R main push other -r e7ec4e813ba6
   pushing to other
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   Fail early!
   transaction abort!
   Cleaning up the mess...
   rollback completed
   abort: pretxnchangegroup hook exited with status 1
   [40]
   $ hg -R main push ssh://user@dummy/other -r e7ec4e813ba6
   pushing to ssh://user@dummy/other
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: Fail early!
   remote: transaction abort!
   remote: Cleaning up the mess...
   remote: rollback completed
   remote: pretxnchangegroup hook exited with status 1
   abort: push failed on remote
-  [255]
+  [100]
   $ hg -R main push http://localhost:$HGPORT2/ -r e7ec4e813ba6
   pushing to http://localhost:$HGPORT2/
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: Fail early!
   remote: transaction abort!
   remote: Cleaning up the mess...
   remote: rollback completed
   remote: pretxnchangegroup hook exited with status 1
   abort: push failed on remote
-  [255]
+  [100]
 
 Check abort from mandatory pushkey
 
   $ cat > mandatorypart.py << EOF
   > from mercurial import exchange
   > from mercurial import pushkey
   > from mercurial import node
   > from mercurial import error
   > @exchange.b2partsgenerator(b'failingpuskey')
   > def addfailingpushey(pushop, bundler):
   >     enc = pushkey.encode
   >     part = bundler.newpart(b'pushkey')
   >     part.addparam(b'namespace', enc(b'phases'))
   >     part.addparam(b'key', enc(b'cd010b8cd998f3981a5a8115f94f8da4ab506089'))
   >     part.addparam(b'old', enc(b'0')) # successful update
   >     part.addparam(b'new', enc(b'0'))
   >     def fail(pushop, exc):
   >         raise error.Abort(b'Correct phase push failed (because hooks)')
   >     pushop.pkfailcb[part.id] = fail
   > EOF
   $ cat >> $HGRCPATH << EOF
   > [hooks]
   > pretxnchangegroup=
   > pretxnclose.failpush=
   > prepushkey.failpush = sh -c "echo 'do not push the key !'; false"
   > [extensions]
   > mandatorypart=$TESTTMP/mandatorypart.py
   > EOF
   $ "$TESTDIR/killdaemons.py" $DAEMON_PIDS # reload http config
   $ hg serve -R other -p $HGPORT2 -d --pid-file=other.pid -E other-error.log
   $ cat other.pid >> $DAEMON_PIDS
 
 (Failure from a hook)
 
   $ hg -R main push other -r e7ec4e813ba6
   pushing to other
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   do not push the key !
   pushkey-abort: prepushkey.failpush hook exited with status 1
   transaction abort!
   Cleaning up the mess...
   rollback completed
   abort: Correct phase push failed (because hooks)
   [255]
   $ hg -R main push ssh://user@dummy/other -r e7ec4e813ba6
   pushing to ssh://user@dummy/other
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: do not push the key !
   remote: pushkey-abort: prepushkey.failpush hook exited with status 1
   remote: transaction abort!
   remote: Cleaning up the mess...
   remote: rollback completed
   abort: Correct phase push failed (because hooks)
   [255]
   $ hg -R main push http://localhost:$HGPORT2/ -r e7ec4e813ba6
   pushing to http://localhost:$HGPORT2/
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: do not push the key !
   remote: pushkey-abort: prepushkey.failpush hook exited with status 1
   remote: transaction abort!
   remote: Cleaning up the mess...
   remote: rollback completed
   abort: Correct phase push failed (because hooks)
   [255]
 
 (Failure from a the pushkey)
 
   $ cat > mandatorypart.py << EOF
   > from mercurial import exchange
   > from mercurial import pushkey
   > from mercurial import node
   > from mercurial import error
   > @exchange.b2partsgenerator(b'failingpuskey')
   > def addfailingpushey(pushop, bundler):
   >     enc = pushkey.encode
   >     part = bundler.newpart(b'pushkey')
   >     part.addparam(b'namespace', enc(b'phases'))
   >     part.addparam(b'key', enc(b'cd010b8cd998f3981a5a8115f94f8da4ab506089'))
   >     part.addparam(b'old', enc(b'4')) # will fail
   >     part.addparam(b'new', enc(b'3'))
   >     def fail(pushop, exc):
   >         raise error.Abort(b'Clown phase push failed')
   >     pushop.pkfailcb[part.id] = fail
   > EOF
   $ cat >> $HGRCPATH << EOF
   > [hooks]
   > prepushkey.failpush =
   > EOF
   $ "$TESTDIR/killdaemons.py" $DAEMON_PIDS # reload http config
   $ hg serve -R other -p $HGPORT2 -d --pid-file=other.pid -E other-error.log
   $ cat other.pid >> $DAEMON_PIDS
 
   $ hg -R main push other -r e7ec4e813ba6
   pushing to other
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   transaction abort!
   Cleaning up the mess...
   rollback completed
   pushkey: lock state after "phases"
   lock:  free
   wlock: free
   abort: Clown phase push failed
   [255]
   $ hg -R main push ssh://user@dummy/other -r e7ec4e813ba6
   pushing to ssh://user@dummy/other
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: transaction abort!
   remote: Cleaning up the mess...
   remote: rollback completed
   remote: pushkey: lock state after "phases"
   remote: lock:  free
   remote: wlock: free
   abort: Clown phase push failed
   [255]
   $ hg -R main push http://localhost:$HGPORT2/ -r e7ec4e813ba6
   pushing to http://localhost:$HGPORT2/
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: transaction abort!
   remote: Cleaning up the mess...
   remote: rollback completed
   remote: pushkey: lock state after "phases"
   remote: lock:  free
   remote: wlock: free
   abort: Clown phase push failed
   [255]
 
 Test lazily acquiring the lock during unbundle
   $ cp $TESTTMP/hgrc.orig $HGRCPATH
   $ cat >> $HGRCPATH <<EOF
   > [ui]
   > ssh="$PYTHON" "$TESTDIR/dummyssh"
   > EOF
 
   $ cat >> $TESTTMP/locktester.py <<EOF
   > import os
   > from mercurial import bundle2, error, extensions
   > def checklock(orig, repo, *args, **kwargs):
   >     if repo.svfs.lexists(b"lock"):
   >         raise error.Abort(b"Lock should not be taken")
   >     return orig(repo, *args, **kwargs)
   > def extsetup(ui):
   >    extensions.wrapfunction(bundle2, b'processbundle', checklock)
   > EOF
 
   $ hg init lazylock
   $ cat >> lazylock/.hg/hgrc <<EOF
   > [extensions]
   > locktester=$TESTTMP/locktester.py
   > EOF
 
   $ hg clone -q ssh://user@dummy/lazylock lazylockclient
   $ cd lazylockclient
   $ touch a && hg ci -Aqm a
   $ hg push
   pushing to ssh://user@dummy/lazylock
   searching for changes
   remote: Lock should not be taken
   abort: push failed on remote
-  [255]
+  [100]
 
   $ cat >> ../lazylock/.hg/hgrc <<EOF
   > [experimental]
   > bundle2lazylocking=True
   > EOF
   $ hg push
   pushing to ssh://user@dummy/lazylock
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 1 changesets with 1 changes to 1 files
 
   $ cd ..
 
 Servers can disable bundle1 for clone/pull operations
 
   $ killdaemons.py
   $ hg init bundle2onlyserver
   $ cd bundle2onlyserver
   $ cat > .hg/hgrc << EOF
   > [server]
   > bundle1.pull = false
   > EOF
 
   $ touch foo
   $ hg -q commit -A -m initial
 
   $ hg serve -p $HGPORT -d --pid-file=hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
 
   $ hg --config devel.legacy.exchange=bundle1 clone http://localhost:$HGPORT/ not-bundle2
   requesting all changes
   abort: remote error:
   incompatible Mercurial client; bundle2 required
   (see https://www.mercurial-scm.org/wiki/IncompatibleClient)
   [100]
   $ killdaemons.py
   $ cd ..
 
 bundle1 can still pull non-generaldelta repos when generaldelta bundle1 disabled
 
   $ hg --config format.usegeneraldelta=false init notgdserver
   $ cd notgdserver
   $ cat > .hg/hgrc << EOF
   > [server]
   > bundle1gd.pull = false
   > EOF
 
   $ touch foo
   $ hg -q commit -A -m initial
   $ hg serve -p $HGPORT -d --pid-file=hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
 
   $ hg --config devel.legacy.exchange=bundle1 clone http://localhost:$HGPORT/ not-bundle2-1
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets 96ee1d7354c4
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ killdaemons.py
   $ cd ../bundle2onlyserver
 
 bundle1 pull can be disabled for generaldelta repos only
 
   $ cat > .hg/hgrc << EOF
   > [server]
   > bundle1gd.pull = false
   > EOF
 
   $ hg serve -p $HGPORT -d --pid-file=hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
   $ hg --config devel.legacy.exchange=bundle1 clone http://localhost:$HGPORT/ not-bundle2
   requesting all changes
   abort: remote error:
   incompatible Mercurial client; bundle2 required
   (see https://www.mercurial-scm.org/wiki/IncompatibleClient)
   [100]
 
   $ killdaemons.py
 
 Verify the global server.bundle1 option works
 
   $ cd ..
   $ cat > bundle2onlyserver/.hg/hgrc << EOF
   > [server]
   > bundle1 = false
   > EOF
   $ hg serve -R bundle2onlyserver -p $HGPORT -d --pid-file=hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
   $ hg --config devel.legacy.exchange=bundle1 clone http://localhost:$HGPORT not-bundle2
   requesting all changes
   abort: remote error:
   incompatible Mercurial client; bundle2 required
   (see https://www.mercurial-scm.org/wiki/IncompatibleClient)
   [100]
   $ killdaemons.py
 
   $ hg --config devel.legacy.exchange=bundle1 clone ssh://user@dummy/bundle2onlyserver not-bundle2-ssh
   requesting all changes
   adding changesets
   remote: abort: incompatible Mercurial client; bundle2 required
   remote: (see https://www.mercurial-scm.org/wiki/IncompatibleClient)
   transaction abort!
   rollback completed
   abort: stream ended unexpectedly (got 0 bytes, expected 4)
   [255]
 
   $ cat > bundle2onlyserver/.hg/hgrc << EOF
   > [server]
   > bundle1gd = false
   > EOF
   $ hg serve -R bundle2onlyserver -p $HGPORT -d --pid-file=hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
 
   $ hg --config devel.legacy.exchange=bundle1 clone http://localhost:$HGPORT/ not-bundle2
   requesting all changes
   abort: remote error:
   incompatible Mercurial client; bundle2 required
   (see https://www.mercurial-scm.org/wiki/IncompatibleClient)
   [100]
 
   $ killdaemons.py
 
   $ cd notgdserver
   $ cat > .hg/hgrc << EOF
   > [server]
   > bundle1gd = false
   > EOF
   $ hg serve -p $HGPORT -d --pid-file=hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
 
   $ hg --config devel.legacy.exchange=bundle1 clone http://localhost:$HGPORT/ not-bundle2-2
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets 96ee1d7354c4
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ killdaemons.py
   $ cd ../bundle2onlyserver
 
 Verify bundle1 pushes can be disabled
 
   $ cat > .hg/hgrc << EOF
   > [server]
   > bundle1.push = false
   > [web]
   > allow_push = *
   > push_ssl = false
   > EOF
 
   $ hg serve -p $HGPORT -d --pid-file=hg.pid -E error.log
   $ cat hg.pid >> $DAEMON_PIDS
   $ cd ..
 
   $ hg clone http://localhost:$HGPORT bundle2-only
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets 96ee1d7354c4
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd bundle2-only
   $ echo commit > foo
   $ hg commit -m commit
   $ hg --config devel.legacy.exchange=bundle1 push
   pushing to http://localhost:$HGPORT/
   searching for changes
   abort: remote error:
   incompatible Mercurial client; bundle2 required
   (see https://www.mercurial-scm.org/wiki/IncompatibleClient)
   [100]
 
 (also check with ssh)
 
   $ hg --config devel.legacy.exchange=bundle1 push ssh://user@dummy/bundle2onlyserver
   pushing to ssh://user@dummy/bundle2onlyserver
   searching for changes
   remote: abort: incompatible Mercurial client; bundle2 required
   remote: (see https://www.mercurial-scm.org/wiki/IncompatibleClient)
   [1]
 
   $ hg push
   pushing to http://localhost:$HGPORT/
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 1 changesets with 1 changes to 1 files

tests/test-bundle2-remote-changegroup.t

@@ -1,610 +1,610 b''
 #testcases sshv1 sshv2
 
 #if sshv2
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > sshpeer.advertise-v2 = true
   > sshserver.support-v2 = true
   > EOF
 #endif
 
 Create an extension to test bundle2 remote-changegroup parts
 
   $ cat > bundle2.py << EOF
   > """A small extension to test bundle2 remote-changegroup parts.
   > 
   > Current bundle2 implementation doesn't provide a way to generate those
   > parts, so they must be created by extensions.
   > """
   > from mercurial import (
   >     bundle2,
   >     changegroup,
   >     discovery,
   >     exchange,
   >     pycompat,
   >     util,
   > )
   > 
   > def _getbundlechangegrouppart(bundler, repo, source, bundlecaps=None,
   >                               b2caps=None, heads=None, common=None,
   >                               **kwargs):
   >     """this function replaces the changegroup part handler for getbundle.
   >     It allows to create a set of arbitrary parts containing changegroups
   >     and remote-changegroups, as described in a bundle2maker file in the
   >     repository .hg/ directory.
   > 
   >     Each line of that bundle2maker file contain a description of the
   >     part to add:
   >       - changegroup common_revset heads_revset
   >           Creates a changegroup part based, using common_revset and
   >           heads_revset for outgoing
   >       - remote-changegroup url file
   >           Creates a remote-changegroup part for a bundle at the given
   >           url. Size and digest, as required by the client, are computed
   >           from the given file.
   >       - raw-remote-changegroup <python expression>
   >           Creates a remote-changegroup part with the data given in the
   >           Python expression as parameters. The Python expression is
   >           evaluated with eval, and is expected to be a dict.
   >     """
   >     def newpart(name, data=b''):
   >         """wrapper around bundler.newpart adding an extra part making the
   >         client output information about each processed part"""
   >         bundler.newpart(b'output', data=name)
   >         part = bundler.newpart(name, data=data)
   >         return part
   > 
   >     for line in open(repo.vfs.join(b'bundle2maker'), 'rb'):
   >         line = line.strip()
   >         try:
   >             verb, args = line.split(None, 1)
   >         except ValueError:
   >             verb, args = line, b''
   >         if verb == b'remote-changegroup':
   >            url, file = args.split()
   >            bundledata = open(file, 'rb').read()
   >            digest = util.digester.preferred(b2caps[b'digests'])
   >            d = util.digester([digest], bundledata)
   >            part = newpart(b'remote-changegroup')
   >            part.addparam(b'url', url)
   >            part.addparam(b'size', b'%d' % len(bundledata))
   >            part.addparam(b'digests', digest)
   >            part.addparam(b'digest:%s' % digest, d[digest])
   >         elif verb == b'raw-remote-changegroup':
   >            part = newpart(b'remote-changegroup')
   >            for k, v in eval(args).items():
   >                part.addparam(pycompat.sysbytes(k), pycompat.bytestr(v))
   >         elif verb == b'changegroup':
   >             _common, heads = args.split()
   >             common.extend(repo[r].node() for r in repo.revs(_common))
   >             heads = [repo[r].node() for r in repo.revs(heads)]
   >             outgoing = discovery.outgoing(repo, common, heads)
   >             cg = changegroup.makechangegroup(repo, outgoing, b'01',
   >                                              b'changegroup')
   >             newpart(b'changegroup', cg.getchunks())
   >         else:
   >             raise Exception('unknown verb')
   > 
   > exchange.getbundle2partsmapping[b'changegroup'] = _getbundlechangegrouppart
   > EOF
 
 Start a simple HTTP server to serve bundles
 
   $ "$PYTHON" "$TESTDIR/dumbhttp.py" -p $HGPORT --pid dumb.pid
   $ cat dumb.pid >> $DAEMON_PIDS
 
   $ cat >> $HGRCPATH << EOF
   > [ui]
   > ssh="$PYTHON" "$TESTDIR/dummyssh"
   > [command-templates]
   > log={rev}:{node|short} {phase} {author} {bookmarks} {desc|firstline}
   > EOF
 
   $ hg init repo
 
   $ hg -R repo unbundle $TESTDIR/bundles/rebase.hg
   adding changesets
   adding manifests
   adding file changes
   added 8 changesets with 7 changes to 7 files (+2 heads)
   new changesets cd010b8cd998:02de42196ebe (8 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
   $ hg -R repo log -G
   o  7:02de42196ebe draft Nicolas Dumazet <[e-mail]>  H
   |
   | o  6:eea13746799a draft Nicolas Dumazet <[e-mail]>  G
   |/|
   o |  5:24b6387c8c8c draft Nicolas Dumazet <[e-mail]>  F
   | |
   | o  4:9520eea781bc draft Nicolas Dumazet <[e-mail]>  E
   |/
   | o  3:32af7686d403 draft Nicolas Dumazet <[e-mail]>  D
   | |
   | o  2:5fddd98957c8 draft Nicolas Dumazet <[e-mail]>  C
   | |
   | o  1:42ccdea3bb16 draft Nicolas Dumazet <[e-mail]>  B
   |/
   o  0:cd010b8cd998 draft Nicolas Dumazet <[e-mail]>  A
   
   $ hg clone repo orig
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cat > repo/.hg/hgrc << EOF
   > [extensions]
   > bundle2=$TESTTMP/bundle2.py
   > EOF
 
 Test a pull with an remote-changegroup
 
   $ hg bundle -R repo --type v1 --base '0:4' -r '5:7' bundle.hg
   3 changesets found
   $ cat > repo/.hg/bundle2maker << EOF
   > remote-changegroup http://localhost:$HGPORT/bundle.hg bundle.hg
   > EOF
   $ hg clone orig clone -r 3 -r 4
   adding changesets
   adding manifests
   adding file changes
   added 5 changesets with 5 changes to 5 files (+1 heads)
   new changesets cd010b8cd998:9520eea781bc
   updating to branch default
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg pull -R clone ssh://user@dummy/repo
   pulling from ssh://user@dummy/repo
   searching for changes
   remote: remote-changegroup
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 2 changes to 2 files (+1 heads)
   new changesets 24b6387c8c8c:02de42196ebe
   (run 'hg heads .' to see heads, 'hg merge' to merge)
   $ hg -R clone log -G
   o  7:02de42196ebe public Nicolas Dumazet <[e-mail]>  H
   |
   | o  6:eea13746799a public Nicolas Dumazet <[e-mail]>  G
   |/|
   o |  5:24b6387c8c8c public Nicolas Dumazet <[e-mail]>  F
   | |
   | o  4:9520eea781bc public Nicolas Dumazet <[e-mail]>  E
   |/
   | @  3:32af7686d403 public Nicolas Dumazet <[e-mail]>  D
   | |
   | o  2:5fddd98957c8 public Nicolas Dumazet <[e-mail]>  C
   | |
   | o  1:42ccdea3bb16 public Nicolas Dumazet <[e-mail]>  B
   |/
   o  0:cd010b8cd998 public Nicolas Dumazet <[e-mail]>  A
   
   $ rm -rf clone
 
 Test a pull with an remote-changegroup and a following changegroup
 
   $ hg bundle -R repo --type v1 --base 2 -r '3:4' bundle2.hg
   2 changesets found
   $ cat > repo/.hg/bundle2maker << EOF
   > remote-changegroup http://localhost:$HGPORT/bundle2.hg bundle2.hg
   > changegroup 0:4 5:7
   > EOF
   $ hg clone orig clone -r 2
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 3 files
   new changesets cd010b8cd998:5fddd98957c8
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg pull -R clone ssh://user@dummy/repo
   pulling from ssh://user@dummy/repo
   searching for changes
   remote: remote-changegroup
   adding changesets
   adding manifests
   adding file changes
   remote: changegroup
   adding changesets
   adding manifests
   adding file changes
   added 5 changesets with 4 changes to 4 files (+2 heads)
   new changesets 32af7686d403:02de42196ebe
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg -R clone log -G
   o  7:02de42196ebe public Nicolas Dumazet <[e-mail]>  H
   |
   | o  6:eea13746799a public Nicolas Dumazet <[e-mail]>  G
   |/|
   o |  5:24b6387c8c8c public Nicolas Dumazet <[e-mail]>  F
   | |
   | o  4:9520eea781bc public Nicolas Dumazet <[e-mail]>  E
   |/
   | o  3:32af7686d403 public Nicolas Dumazet <[e-mail]>  D
   | |
   | @  2:5fddd98957c8 public Nicolas Dumazet <[e-mail]>  C
   | |
   | o  1:42ccdea3bb16 public Nicolas Dumazet <[e-mail]>  B
   |/
   o  0:cd010b8cd998 public Nicolas Dumazet <[e-mail]>  A
   
   $ rm -rf clone
 
 Test a pull with a changegroup followed by an remote-changegroup
 
   $ hg bundle -R repo --type v1 --base '0:4' -r '5:7' bundle3.hg
   3 changesets found
   $ cat > repo/.hg/bundle2maker << EOF
   > changegroup 000000000000 :4
   > remote-changegroup http://localhost:$HGPORT/bundle3.hg bundle3.hg
   > EOF
   $ hg clone orig clone -r 2
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 3 files
   new changesets cd010b8cd998:5fddd98957c8
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg pull -R clone ssh://user@dummy/repo
   pulling from ssh://user@dummy/repo
   searching for changes
   remote: changegroup
   adding changesets
   adding manifests
   adding file changes
   remote: remote-changegroup
   adding changesets
   adding manifests
   adding file changes
   added 5 changesets with 4 changes to 4 files (+2 heads)
   new changesets 32af7686d403:02de42196ebe
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg -R clone log -G
   o  7:02de42196ebe public Nicolas Dumazet <[e-mail]>  H
   |
   | o  6:eea13746799a public Nicolas Dumazet <[e-mail]>  G
   |/|
   o |  5:24b6387c8c8c public Nicolas Dumazet <[e-mail]>  F
   | |
   | o  4:9520eea781bc public Nicolas Dumazet <[e-mail]>  E
   |/
   | o  3:32af7686d403 public Nicolas Dumazet <[e-mail]>  D
   | |
   | @  2:5fddd98957c8 public Nicolas Dumazet <[e-mail]>  C
   | |
   | o  1:42ccdea3bb16 public Nicolas Dumazet <[e-mail]>  B
   |/
   o  0:cd010b8cd998 public Nicolas Dumazet <[e-mail]>  A
   
   $ rm -rf clone
 
 Test a pull with two remote-changegroups and a changegroup
 
   $ hg bundle -R repo --type v1 --base 2 -r '3:4' bundle4.hg
   2 changesets found
   $ hg bundle -R repo --type v1 --base '3:4' -r '5:6' bundle5.hg
   2 changesets found
   $ cat > repo/.hg/bundle2maker << EOF
   > remote-changegroup http://localhost:$HGPORT/bundle4.hg bundle4.hg
   > remote-changegroup http://localhost:$HGPORT/bundle5.hg bundle5.hg
   > changegroup 0:6 7
   > EOF
   $ hg clone orig clone -r 2
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 3 files
   new changesets cd010b8cd998:5fddd98957c8
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg pull -R clone ssh://user@dummy/repo
   pulling from ssh://user@dummy/repo
   searching for changes
   remote: remote-changegroup
   adding changesets
   adding manifests
   adding file changes
   remote: remote-changegroup
   adding changesets
   adding manifests
   adding file changes
   remote: changegroup
   adding changesets
   adding manifests
   adding file changes
   added 5 changesets with 4 changes to 4 files (+2 heads)
   new changesets 32af7686d403:02de42196ebe
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg -R clone log -G
   o  7:02de42196ebe public Nicolas Dumazet <[e-mail]>  H
   |
   | o  6:eea13746799a public Nicolas Dumazet <[e-mail]>  G
   |/|
   o |  5:24b6387c8c8c public Nicolas Dumazet <[e-mail]>  F
   | |
   | o  4:9520eea781bc public Nicolas Dumazet <[e-mail]>  E
   |/
   | o  3:32af7686d403 public Nicolas Dumazet <[e-mail]>  D
   | |
   | @  2:5fddd98957c8 public Nicolas Dumazet <[e-mail]>  C
   | |
   | o  1:42ccdea3bb16 public Nicolas Dumazet <[e-mail]>  B
   |/
   o  0:cd010b8cd998 public Nicolas Dumazet <[e-mail]>  A
   
   $ rm -rf clone
 
 Hash digest tests
 
   $ hg bundle -R repo --type v1 -a bundle6.hg
   8 changesets found
 
   $ cat > repo/.hg/bundle2maker << EOF
   > raw-remote-changegroup {'url': 'http://localhost:$HGPORT/bundle6.hg', 'size': 1663, 'digests': 'sha1', 'digest:sha1': '2c880cfec23cff7d8f80c2f12958d1563cbdaba6'}
   > EOF
   $ hg clone ssh://user@dummy/repo clone
   requesting all changes
   remote: remote-changegroup
   adding changesets
   adding manifests
   adding file changes
   added 8 changesets with 7 changes to 7 files (+2 heads)
   new changesets cd010b8cd998:02de42196ebe
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ rm -rf clone
 
   $ cat > repo/.hg/bundle2maker << EOF
   > raw-remote-changegroup {'url': 'http://localhost:$HGPORT/bundle6.hg', 'size': 1663, 'digests': 'md5', 'digest:md5': 'e22172c2907ef88794b7bea6642c2394'}
   > EOF
   $ hg clone ssh://user@dummy/repo clone
   requesting all changes
   remote: remote-changegroup
   adding changesets
   adding manifests
   adding file changes
   added 8 changesets with 7 changes to 7 files (+2 heads)
   new changesets cd010b8cd998:02de42196ebe
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ rm -rf clone
 
 Hash digest mismatch throws an error
 
   $ cat > repo/.hg/bundle2maker << EOF
   > raw-remote-changegroup {'url': 'http://localhost:$HGPORT/bundle6.hg', 'size': 1663, 'digests': 'sha1', 'digest:sha1': '0' * 40}
   > EOF
   $ hg clone ssh://user@dummy/repo clone
   requesting all changes
   remote: remote-changegroup
   adding changesets
   adding manifests
   adding file changes
   transaction abort!
   rollback completed
   abort: bundle at http://localhost:$HGPORT/bundle6.hg is corrupted:
   sha1 mismatch: expected 0000000000000000000000000000000000000000, got 2c880cfec23cff7d8f80c2f12958d1563cbdaba6
   [255]
 
 Multiple hash digests can be given
 
   $ cat > repo/.hg/bundle2maker << EOF
   > raw-remote-changegroup {'url': 'http://localhost:$HGPORT/bundle6.hg', 'size': 1663, 'digests': 'md5 sha1', 'digest:md5': 'e22172c2907ef88794b7bea6642c2394', 'digest:sha1': '2c880cfec23cff7d8f80c2f12958d1563cbdaba6'}
   > EOF
   $ hg clone ssh://user@dummy/repo clone
   requesting all changes
   remote: remote-changegroup
   adding changesets
   adding manifests
   adding file changes
   added 8 changesets with 7 changes to 7 files (+2 heads)
   new changesets cd010b8cd998:02de42196ebe
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ rm -rf clone
 
 If either of the multiple hash digests mismatches, an error is thrown
 
   $ cat > repo/.hg/bundle2maker << EOF
   > raw-remote-changegroup {'url': 'http://localhost:$HGPORT/bundle6.hg', 'size': 1663, 'digests': 'md5 sha1', 'digest:md5': '0' * 32, 'digest:sha1': '2c880cfec23cff7d8f80c2f12958d1563cbdaba6'}
   > EOF
   $ hg clone ssh://user@dummy/repo clone
   requesting all changes
   remote: remote-changegroup
   adding changesets
   adding manifests
   adding file changes
   transaction abort!
   rollback completed
   abort: bundle at http://localhost:$HGPORT/bundle6.hg is corrupted:
   md5 mismatch: expected 00000000000000000000000000000000, got e22172c2907ef88794b7bea6642c2394
   [255]
 
   $ cat > repo/.hg/bundle2maker << EOF
   > raw-remote-changegroup {'url': 'http://localhost:$HGPORT/bundle6.hg', 'size': 1663, 'digests': 'md5 sha1', 'digest:md5': 'e22172c2907ef88794b7bea6642c2394', 'digest:sha1': '0' * 40}
   > EOF
   $ hg clone ssh://user@dummy/repo clone
   requesting all changes
   remote: remote-changegroup
   adding changesets
   adding manifests
   adding file changes
   transaction abort!
   rollback completed
   abort: bundle at http://localhost:$HGPORT/bundle6.hg is corrupted:
   sha1 mismatch: expected 0000000000000000000000000000000000000000, got 2c880cfec23cff7d8f80c2f12958d1563cbdaba6
   [255]
 
 Corruption tests
 
   $ hg clone orig clone -r 2
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 3 files
   new changesets cd010b8cd998:5fddd98957c8
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cat > repo/.hg/bundle2maker << EOF
   > remote-changegroup http://localhost:$HGPORT/bundle4.hg bundle4.hg
   > raw-remote-changegroup {'url': 'http://localhost:$HGPORT/bundle5.hg', 'size': 578, 'digests': 'sha1', 'digest:sha1': '0' * 40}
   > changegroup 0:6 7
   > EOF
   $ hg pull -R clone ssh://user@dummy/repo
   pulling from ssh://user@dummy/repo
   searching for changes
   remote: remote-changegroup
   adding changesets
   adding manifests
   adding file changes
   remote: remote-changegroup
   adding changesets
   adding manifests
   adding file changes
   transaction abort!
   rollback completed
   abort: bundle at http://localhost:$HGPORT/bundle5.hg is corrupted:
   sha1 mismatch: expected 0000000000000000000000000000000000000000, got f29485d6bfd37db99983cfc95ecb52f8ca396106
   [255]
 
 The entire transaction has been rolled back in the pull above
 
   $ hg -R clone log -G
   @  2:5fddd98957c8 public Nicolas Dumazet <[e-mail]>  C
   |
   o  1:42ccdea3bb16 public Nicolas Dumazet <[e-mail]>  B
   |
   o  0:cd010b8cd998 public Nicolas Dumazet <[e-mail]>  A
   
 
 No params
 
   $ cat > repo/.hg/bundle2maker << EOF
   > raw-remote-changegroup {}
   > EOF
   $ hg pull -R clone ssh://user@dummy/repo
   pulling from ssh://user@dummy/repo
   searching for changes
   remote: remote-changegroup
   abort: remote-changegroup: missing "url" param
   [255]
 
 Missing size
 
   $ cat > repo/.hg/bundle2maker << EOF
   > raw-remote-changegroup {'url': 'http://localhost:$HGPORT/bundle4.hg'}
   > EOF
   $ hg pull -R clone ssh://user@dummy/repo
   pulling from ssh://user@dummy/repo
   searching for changes
   remote: remote-changegroup
   abort: remote-changegroup: missing "size" param
   [255]
 
 Invalid size
 
   $ cat > repo/.hg/bundle2maker << EOF
   > raw-remote-changegroup {'url': 'http://localhost:$HGPORT/bundle4.hg', 'size': 'foo'}
   > EOF
   $ hg pull -R clone ssh://user@dummy/repo
   pulling from ssh://user@dummy/repo
   searching for changes
   remote: remote-changegroup
   abort: remote-changegroup: invalid value for param "size"
   [255]
 
 Size mismatch
 
   $ cat > repo/.hg/bundle2maker << EOF
   > raw-remote-changegroup {'url': 'http://localhost:$HGPORT/bundle4.hg', 'size': 42}
   > EOF
   $ hg pull -R clone ssh://user@dummy/repo
   pulling from ssh://user@dummy/repo
   searching for changes
   remote: remote-changegroup
   adding changesets
   adding manifests
   adding file changes
   transaction abort!
   rollback completed
   abort: bundle at http://localhost:$HGPORT/bundle4.hg is corrupted:
   size mismatch: expected 42, got 581
   [255]
 
 Unknown digest
 
   $ cat > repo/.hg/bundle2maker << EOF
   > raw-remote-changegroup {'url': 'http://localhost:$HGPORT/bundle4.hg', 'size': 581, 'digests': 'foo', 'digest:foo': 'bar'}
   > EOF
   $ hg pull -R clone ssh://user@dummy/repo
   pulling from ssh://user@dummy/repo
   searching for changes
   remote: remote-changegroup
   abort: missing support for remote-changegroup - digest:foo
-  [255]
+  [100]
 
 Missing digest
 
   $ cat > repo/.hg/bundle2maker << EOF
   > raw-remote-changegroup {'url': 'http://localhost:$HGPORT/bundle4.hg', 'size': 581, 'digests': 'sha1'}
   > EOF
   $ hg pull -R clone ssh://user@dummy/repo
   pulling from ssh://user@dummy/repo
   searching for changes
   remote: remote-changegroup
   abort: remote-changegroup: missing "digest:sha1" param
   [255]
 
 Not an HTTP url
 
   $ cat > repo/.hg/bundle2maker << EOF
   > raw-remote-changegroup {'url': 'ssh://localhost:$HGPORT/bundle4.hg', 'size': 581}
   > EOF
   $ hg pull -R clone ssh://user@dummy/repo
   pulling from ssh://user@dummy/repo
   searching for changes
   remote: remote-changegroup
   abort: remote-changegroup does not support ssh urls
   [255]
 
 Not a bundle
 
   $ cat > notbundle.hg << EOF
   > foo
   > EOF
   $ cat > repo/.hg/bundle2maker << EOF
   > remote-changegroup http://localhost:$HGPORT/notbundle.hg notbundle.hg
   > EOF
   $ hg pull -R clone ssh://user@dummy/repo
   pulling from ssh://user@dummy/repo
   searching for changes
   remote: remote-changegroup
   abort: http://localhost:$HGPORT/notbundle.hg: not a Mercurial bundle
   [255]
 
 Not a bundle 1.0
 
   $ cat > notbundle10.hg << EOF
   > HG20
   > EOF
   $ cat > repo/.hg/bundle2maker << EOF
   > remote-changegroup http://localhost:$HGPORT/notbundle10.hg notbundle10.hg
   > EOF
   $ hg pull -R clone ssh://user@dummy/repo
   pulling from ssh://user@dummy/repo
   searching for changes
   remote: remote-changegroup
   abort: http://localhost:$HGPORT/notbundle10.hg: not a bundle version 1.0
   [255]
 
   $ hg -R clone log -G
   @  2:5fddd98957c8 public Nicolas Dumazet <[e-mail]>  C
   |
   o  1:42ccdea3bb16 public Nicolas Dumazet <[e-mail]>  B
   |
   o  0:cd010b8cd998 public Nicolas Dumazet <[e-mail]>  A
   
   $ rm -rf clone
 
   $ killdaemons.py

tests/test-clone-uncompressed.t

@@ -1,636 +1,636 b''
 #require serve no-reposimplestore no-chg
 
 #testcases stream-legacy stream-bundle2
 
 #if stream-legacy
   $ cat << EOF >> $HGRCPATH
   > [server]
   > bundle2.stream = no
   > EOF
 #endif
 
 Initialize repository
 the status call is to check for issue5130
 
   $ hg init server
   $ cd server
   $ touch foo
   $ hg -q commit -A -m initial
   >>> for i in range(1024):
   ...     with open(str(i), 'wb') as fh:
   ...         fh.write(b"%d" % i) and None
   $ hg -q commit -A -m 'add a lot of files'
   $ hg st
   $ hg --config server.uncompressed=false serve -p $HGPORT -d --pid-file=hg.pid
   $ cat hg.pid > $DAEMON_PIDS
   $ cd ..
 
 Cannot stream clone when server.uncompressed is set
 
   $ get-with-headers.py $LOCALIP:$HGPORT '?cmd=stream_out'
   200 Script output follows
   
   1
 
 #if stream-legacy
   $ hg debugcapabilities http://localhost:$HGPORT
   Main capabilities:
     batch
     branchmap
     $USUAL_BUNDLE2_CAPS_SERVER$
     changegroupsubset
     compression=$BUNDLE2_COMPRESSIONS$
     getbundle
     httpheader=1024
     httpmediatype=0.1rx,0.1tx,0.2tx
     known
     lookup
     pushkey
     unbundle=HG10GZ,HG10BZ,HG10UN
     unbundlehash
   Bundle2 capabilities:
     HG20
     bookmarks
     changegroup
       01
       02
     checkheads
       related
     digests
       md5
       sha1
       sha512
     error
       abort
       unsupportedcontent
       pushraced
       pushkey
     hgtagsfnodes
     listkeys
     phases
       heads
     pushkey
     remote-changegroup
       http
       https
 
   $ hg clone --stream -U http://localhost:$HGPORT server-disabled
   warning: stream clone requested but server has them disabled
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 1025 changes to 1025 files
   new changesets 96ee1d7354c4:c17445101a72
 
   $ get-with-headers.py $LOCALIP:$HGPORT '?cmd=getbundle' content-type --bodyfile body --hgproto 0.2 --requestheader "x-hgarg-1=bundlecaps=HG20%2Cbundle2%3DHG20%250Abookmarks%250Achangegroup%253D01%252C02%250Adigests%253Dmd5%252Csha1%252Csha512%250Aerror%253Dabort%252Cunsupportedcontent%252Cpushraced%252Cpushkey%250Ahgtagsfnodes%250Alistkeys%250Aphases%253Dheads%250Apushkey%250Aremote-changegroup%253Dhttp%252Chttps&cg=0&common=0000000000000000000000000000000000000000&heads=c17445101a72edac06facd130d14808dfbd5c7c2&stream=1"
   200 Script output follows
   content-type: application/mercurial-0.2
   
 
   $ f --size body --hexdump --bytes 100
   body: size=232
   0000: 04 6e 6f 6e 65 48 47 32 30 00 00 00 00 00 00 00 |.noneHG20.......|
   0010: cf 0b 45 52 52 4f 52 3a 41 42 4f 52 54 00 00 00 |..ERROR:ABORT...|
   0020: 00 01 01 07 3c 04 72 6d 65 73 73 61 67 65 73 74 |....<.rmessagest|
   0030: 72 65 61 6d 20 64 61 74 61 20 72 65 71 75 65 73 |ream data reques|
   0040: 74 65 64 20 62 75 74 20 73 65 72 76 65 72 20 64 |ted but server d|
   0050: 6f 65 73 20 6e 6f 74 20 61 6c 6c 6f 77 20 74 68 |oes not allow th|
   0060: 69 73 20 66                                     |is f|
 
 #endif
 #if stream-bundle2
   $ hg debugcapabilities http://localhost:$HGPORT
   Main capabilities:
     batch
     branchmap
     $USUAL_BUNDLE2_CAPS_SERVER$
     changegroupsubset
     compression=$BUNDLE2_COMPRESSIONS$
     getbundle
     httpheader=1024
     httpmediatype=0.1rx,0.1tx,0.2tx
     known
     lookup
     pushkey
     unbundle=HG10GZ,HG10BZ,HG10UN
     unbundlehash
   Bundle2 capabilities:
     HG20
     bookmarks
     changegroup
       01
       02
     checkheads
       related
     digests
       md5
       sha1
       sha512
     error
       abort
       unsupportedcontent
       pushraced
       pushkey
     hgtagsfnodes
     listkeys
     phases
       heads
     pushkey
     remote-changegroup
       http
       https
 
   $ hg clone --stream -U http://localhost:$HGPORT server-disabled
   warning: stream clone requested but server has them disabled
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 1025 changes to 1025 files
   new changesets 96ee1d7354c4:c17445101a72
 
   $ get-with-headers.py $LOCALIP:$HGPORT '?cmd=getbundle' content-type --bodyfile body --hgproto 0.2 --requestheader "x-hgarg-1=bundlecaps=HG20%2Cbundle2%3DHG20%250Abookmarks%250Achangegroup%253D01%252C02%250Adigests%253Dmd5%252Csha1%252Csha512%250Aerror%253Dabort%252Cunsupportedcontent%252Cpushraced%252Cpushkey%250Ahgtagsfnodes%250Alistkeys%250Aphases%253Dheads%250Apushkey%250Aremote-changegroup%253Dhttp%252Chttps&cg=0&common=0000000000000000000000000000000000000000&heads=c17445101a72edac06facd130d14808dfbd5c7c2&stream=1"
   200 Script output follows
   content-type: application/mercurial-0.2
   
 
   $ f --size body --hexdump --bytes 100
   body: size=232
   0000: 04 6e 6f 6e 65 48 47 32 30 00 00 00 00 00 00 00 |.noneHG20.......|
   0010: cf 0b 45 52 52 4f 52 3a 41 42 4f 52 54 00 00 00 |..ERROR:ABORT...|
   0020: 00 01 01 07 3c 04 72 6d 65 73 73 61 67 65 73 74 |....<.rmessagest|
   0030: 72 65 61 6d 20 64 61 74 61 20 72 65 71 75 65 73 |ream data reques|
   0040: 74 65 64 20 62 75 74 20 73 65 72 76 65 72 20 64 |ted but server d|
   0050: 6f 65 73 20 6e 6f 74 20 61 6c 6c 6f 77 20 74 68 |oes not allow th|
   0060: 69 73 20 66                                     |is f|
 
 #endif
 
   $ killdaemons.py
   $ cd server
   $ hg serve -p $HGPORT -d --pid-file=hg.pid
   $ cat hg.pid > $DAEMON_PIDS
   $ cd ..
 
 Basic clone
 
 #if stream-legacy
   $ hg clone --stream -U http://localhost:$HGPORT clone1
   streaming all changes
   1027 files to transfer, 96.3 KB of data (no-zstd !)
   transferred 96.3 KB in * seconds (*/sec) (glob) (no-zstd !)
   1027 files to transfer, 93.5 KB of data (zstd !)
   transferred 93.5 KB in * seconds (* */sec) (glob) (zstd !)
   searching for changes
   no changes found
 #endif
 #if stream-bundle2
   $ hg clone --stream -U http://localhost:$HGPORT clone1
   streaming all changes
   1030 files to transfer, 96.5 KB of data (no-zstd !)
   transferred 96.5 KB in * seconds (*/sec) (glob) (no-zstd !)
   1030 files to transfer, 93.6 KB of data (zstd !)
   transferred 93.6 KB in * seconds (* */sec) (glob) (zstd !)
 
   $ ls -1 clone1/.hg/cache
   branch2-base
   branch2-immutable
   branch2-served
   branch2-served.hidden
   branch2-visible
   branch2-visible-hidden
   hgtagsfnodes1
   rbc-names-v1
   rbc-revs-v1
   tags2
   tags2-served
 #endif
 
 getbundle requests with stream=1 are uncompressed
 
   $ get-with-headers.py $LOCALIP:$HGPORT '?cmd=getbundle' content-type --bodyfile body --hgproto '0.1 0.2 comp=zlib,none' --requestheader "x-hgarg-1=bundlecaps=HG20%2Cbundle2%3DHG20%250Abookmarks%250Achangegroup%253D01%252C02%250Adigests%253Dmd5%252Csha1%252Csha512%250Aerror%253Dabort%252Cunsupportedcontent%252Cpushraced%252Cpushkey%250Ahgtagsfnodes%250Alistkeys%250Aphases%253Dheads%250Apushkey%250Aremote-changegroup%253Dhttp%252Chttps&cg=0&common=0000000000000000000000000000000000000000&heads=c17445101a72edac06facd130d14808dfbd5c7c2&stream=1"
   200 Script output follows
   content-type: application/mercurial-0.2
   
 
   $ f --size --hex --bytes 256 body
   body: size=112262 (no-zstd !)
   body: size=109410 (zstd no-rust !)
   body: size=109431 (rust !)
   0000: 04 6e 6f 6e 65 48 47 32 30 00 00 00 00 00 00 00 |.noneHG20.......|
   0010: 7f 07 53 54 52 45 41 4d 32 00 00 00 00 03 00 09 |..STREAM2.......| (no-zstd !)
   0020: 05 09 04 0c 44 62 79 74 65 63 6f 75 6e 74 39 38 |....Dbytecount98| (no-zstd !)
   0030: 37 37 35 66 69 6c 65 63 6f 75 6e 74 31 30 33 30 |775filecount1030| (no-zstd !)
   0010: 99 07 53 54 52 45 41 4d 32 00 00 00 00 03 00 09 |..STREAM2.......| (zstd no-rust !)
   0010: ae 07 53 54 52 45 41 4d 32 00 00 00 00 03 00 09 |..STREAM2.......| (rust !)
   0020: 05 09 04 0c 5e 62 79 74 65 63 6f 75 6e 74 39 35 |....^bytecount95| (zstd no-rust !)
   0020: 05 09 04 0c 73 62 79 74 65 63 6f 75 6e 74 39 35 |....sbytecount95| (rust !)
   0030: 38 39 37 66 69 6c 65 63 6f 75 6e 74 31 30 33 30 |897filecount1030| (zstd !)
   0040: 72 65 71 75 69 72 65 6d 65 6e 74 73 64 6f 74 65 |requirementsdote|
   0050: 6e 63 6f 64 65 25 32 43 66 6e 63 61 63 68 65 25 |ncode%2Cfncache%|
   0060: 32 43 67 65 6e 65 72 61 6c 64 65 6c 74 61 25 32 |2Cgeneraldelta%2|
   0070: 43 72 65 76 6c 6f 67 76 31 25 32 43 73 70 61 72 |Crevlogv1%2Cspar| (no-zstd !)
   0080: 73 65 72 65 76 6c 6f 67 25 32 43 73 74 6f 72 65 |serevlog%2Cstore| (no-zstd !)
   0090: 00 00 80 00 73 08 42 64 61 74 61 2f 30 2e 69 00 |....s.Bdata/0.i.| (no-zstd !)
   00a0: 03 00 01 00 00 00 00 00 00 00 02 00 00 00 01 00 |................| (no-zstd !)
   00b0: 00 00 00 00 00 00 01 ff ff ff ff ff ff ff ff 80 |................| (no-zstd !)
   00c0: 29 63 a0 49 d3 23 87 bf ce fe 56 67 92 67 2c 69 |)c.I.#....Vg.g,i| (no-zstd !)
   00d0: d1 ec 39 00 00 00 00 00 00 00 00 00 00 00 00 75 |..9............u| (no-zstd !)
   00e0: 30 73 08 42 64 61 74 61 2f 31 2e 69 00 03 00 01 |0s.Bdata/1.i....| (no-zstd !)
   00f0: 00 00 00 00 00 00 00 02 00 00 00 01 00 00 00 00 |................| (no-zstd !)
   0070: 43 72 65 76 6c 6f 67 2d 63 6f 6d 70 72 65 73 73 |Crevlog-compress| (zstd no-rust !)
   0070: 43 70 65 72 73 69 73 74 65 6e 74 2d 6e 6f 64 65 |Cpersistent-node| (rust !)
   0080: 69 6f 6e 2d 7a 73 74 64 25 32 43 72 65 76 6c 6f |ion-zstd%2Crevlo| (zstd no-rust !)
   0080: 6d 61 70 25 32 43 72 65 76 6c 6f 67 2d 63 6f 6d |map%2Crevlog-com| (rust !)
   0090: 67 76 31 25 32 43 73 70 61 72 73 65 72 65 76 6c |gv1%2Csparserevl| (zstd no-rust !)
   0090: 70 72 65 73 73 69 6f 6e 2d 7a 73 74 64 25 32 43 |pression-zstd%2C| (rust !)
   00a0: 6f 67 25 32 43 73 74 6f 72 65 00 00 80 00 73 08 |og%2Cstore....s.| (zstd no-rust !)
   00a0: 72 65 76 6c 6f 67 76 31 25 32 43 73 70 61 72 73 |revlogv1%2Cspars| (rust !)
   00b0: 42 64 61 74 61 2f 30 2e 69 00 03 00 01 00 00 00 |Bdata/0.i.......| (zstd no-rust !)
   00b0: 65 72 65 76 6c 6f 67 25 32 43 73 74 6f 72 65 00 |erevlog%2Cstore.| (rust !)
   00c0: 00 00 00 00 02 00 00 00 01 00 00 00 00 00 00 00 |................| (zstd no-rust !)
   00c0: 00 80 00 73 08 42 64 61 74 61 2f 30 2e 69 00 03 |...s.Bdata/0.i..| (rust !)
   00d0: 01 ff ff ff ff ff ff ff ff 80 29 63 a0 49 d3 23 |..........)c.I.#| (zstd no-rust !)
   00d0: 00 01 00 00 00 00 00 00 00 02 00 00 00 01 00 00 |................| (rust !)
   00e0: 87 bf ce fe 56 67 92 67 2c 69 d1 ec 39 00 00 00 |....Vg.g,i..9...| (zstd no-rust !)
   00e0: 00 00 00 00 00 01 ff ff ff ff ff ff ff ff 80 29 |...............)| (rust !)
   00f0: 00 00 00 00 00 00 00 00 00 75 30 73 08 42 64 61 |.........u0s.Bda| (zstd no-rust !)
   00f0: 63 a0 49 d3 23 87 bf ce fe 56 67 92 67 2c 69 d1 |c.I.#....Vg.g,i.| (rust !)
 
 --uncompressed is an alias to --stream
 
 #if stream-legacy
   $ hg clone --uncompressed -U http://localhost:$HGPORT clone1-uncompressed
   streaming all changes
   1027 files to transfer, 96.3 KB of data (no-zstd !)
   transferred 96.3 KB in * seconds (*/sec) (glob) (no-zstd !)
   1027 files to transfer, 93.5 KB of data (zstd !)
   transferred 93.5 KB in * seconds (* */sec) (glob) (zstd !)
   searching for changes
   no changes found
 #endif
 #if stream-bundle2
   $ hg clone --uncompressed -U http://localhost:$HGPORT clone1-uncompressed
   streaming all changes
   1030 files to transfer, 96.5 KB of data (no-zstd !)
   transferred 96.5 KB in * seconds (* */sec) (glob) (no-zstd !)
   1030 files to transfer, 93.6 KB of data (zstd !)
   transferred 93.6 KB in * seconds (* */sec) (glob) (zstd !)
 #endif
 
 Clone with background file closing enabled
 
 #if stream-legacy
   $ hg --debug --config worker.backgroundclose=true --config worker.backgroundcloseminfilecount=1 clone --stream -U http://localhost:$HGPORT clone-background | grep -v adding
   using http://localhost:$HGPORT/
   sending capabilities command
   sending branchmap command
   streaming all changes
   sending stream_out command
   1027 files to transfer, 96.3 KB of data (no-zstd !)
   1027 files to transfer, 93.5 KB of data (zstd !)
   starting 4 threads for background file closing
   updating the branch cache
   transferred 96.3 KB in * seconds (*/sec) (glob) (no-zstd !)
   transferred 93.5 KB in * seconds (* */sec) (glob) (zstd !)
   query 1; heads
   sending batch command
   searching for changes
   all remote heads known locally
   no changes found
   sending getbundle command
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "listkeys" (params: 1 mandatory) supported
   bundle2-input-part: "phase-heads" supported
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 2 parts total
   checking for updated bookmarks
   updating the branch cache
   (sent 5 HTTP requests and * bytes; received * bytes in responses) (glob)
 #endif
 #if stream-bundle2
   $ hg --debug --config worker.backgroundclose=true --config worker.backgroundcloseminfilecount=1 clone --stream -U http://localhost:$HGPORT clone-background | grep -v adding
   using http://localhost:$HGPORT/
   sending capabilities command
   query 1; heads
   sending batch command
   streaming all changes
   sending getbundle command
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "stream2" (params: 3 mandatory) supported
   applying stream bundle
   1030 files to transfer, 96.5 KB of data (no-zstd !)
   1030 files to transfer, 93.6 KB of data (zstd !)
   starting 4 threads for background file closing
   starting 4 threads for background file closing
   updating the branch cache
   transferred 96.5 KB in * seconds (* */sec) (glob) (no-zstd !)
   bundle2-input-part: total payload size 112094 (no-zstd !)
   transferred 93.6 KB in * seconds (* */sec) (glob) (zstd !)
   bundle2-input-part: total payload size 109216 (zstd !)
   bundle2-input-part: "listkeys" (params: 1 mandatory) supported
   bundle2-input-bundle: 2 parts total
   checking for updated bookmarks
   updating the branch cache
   (sent 3 HTTP requests and * bytes; received * bytes in responses) (glob)
 #endif
 
 Cannot stream clone when there are secret changesets
 
   $ hg -R server phase --force --secret -r tip
   $ hg clone --stream -U http://localhost:$HGPORT secret-denied
   warning: stream clone requested but server has them disabled
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets 96ee1d7354c4
 
   $ killdaemons.py
 
 Streaming of secrets can be overridden by server config
 
   $ cd server
   $ hg serve --config server.uncompressedallowsecret=true -p $HGPORT -d --pid-file=hg.pid
   $ cat hg.pid > $DAEMON_PIDS
   $ cd ..
 
 #if stream-legacy
   $ hg clone --stream -U http://localhost:$HGPORT secret-allowed
   streaming all changes
   1027 files to transfer, 96.3 KB of data (no-zstd !)
   transferred 96.3 KB in * seconds (*/sec) (glob) (no-zstd !)
   1027 files to transfer, 93.5 KB of data (zstd !)
   transferred 93.5 KB in * seconds (* */sec) (glob) (zstd !)
   searching for changes
   no changes found
 #endif
 #if stream-bundle2
   $ hg clone --stream -U http://localhost:$HGPORT secret-allowed
   streaming all changes
   1030 files to transfer, 96.5 KB of data (no-zstd !)
   transferred 96.5 KB in * seconds (* */sec) (glob) (no-zstd !)
   1030 files to transfer, 93.6 KB of data (zstd !)
   transferred 93.6 KB in * seconds (* */sec) (glob) (zstd !)
 #endif
 
   $ killdaemons.py
 
 Verify interaction between preferuncompressed and secret presence
 
   $ cd server
   $ hg serve --config server.preferuncompressed=true -p $HGPORT -d --pid-file=hg.pid
   $ cat hg.pid > $DAEMON_PIDS
   $ cd ..
 
   $ hg clone -U http://localhost:$HGPORT preferuncompressed-secret
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets 96ee1d7354c4
 
   $ killdaemons.py
 
 Clone not allowed when full bundles disabled and can't serve secrets
 
   $ cd server
   $ hg serve --config server.disablefullbundle=true -p $HGPORT -d --pid-file=hg.pid
   $ cat hg.pid > $DAEMON_PIDS
   $ cd ..
 
   $ hg clone --stream http://localhost:$HGPORT secret-full-disabled
   warning: stream clone requested but server has them disabled
   requesting all changes
   remote: abort: server has pull-based clones disabled
   abort: pull failed on remote
   (remove --pull if specified or upgrade Mercurial)
-  [255]
+  [100]
 
 Local stream clone with secrets involved
 (This is just a test over behavior: if you have access to the repo's files,
 there is no security so it isn't important to prevent a clone here.)
 
   $ hg clone -U --stream server local-secret
   warning: stream clone requested but server has them disabled
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets 96ee1d7354c4
 
 Stream clone while repo is changing:
 
   $ mkdir changing
   $ cd changing
 
 extension for delaying the server process so we reliably can modify the repo
 while cloning
 
   $ cat > delayer.py <<EOF
   > import time
   > from mercurial import extensions, vfs
   > def __call__(orig, self, path, *args, **kwargs):
   >     if path == 'data/f1.i':
   >         time.sleep(2)
   >     return orig(self, path, *args, **kwargs)
   > extensions.wrapfunction(vfs.vfs, '__call__', __call__)
   > EOF
 
 prepare repo with small and big file to cover both code paths in emitrevlogdata
 
   $ hg init repo
   $ touch repo/f1
   $ $TESTDIR/seq.py 50000 > repo/f2
   $ hg -R repo ci -Aqm "0"
   $ hg serve -R repo -p $HGPORT1 -d --pid-file=hg.pid --config extensions.delayer=delayer.py
   $ cat hg.pid >> $DAEMON_PIDS
 
 clone while modifying the repo between stating file with write lock and
 actually serving file content
 
   $ hg clone -q --stream -U http://localhost:$HGPORT1 clone &
   $ sleep 1
   $ echo >> repo/f1
   $ echo >> repo/f2
   $ hg -R repo ci -m "1" --config ui.timeout.warn=-1
   $ wait
   $ hg -R clone id
   000000000000
   $ cd ..
 
 Stream repository with bookmarks
 --------------------------------
 
 (revert introduction of secret changeset)
 
   $ hg -R server phase --draft 'secret()'
 
 add a bookmark
 
   $ hg -R server bookmark -r tip some-bookmark
 
 clone it
 
 #if stream-legacy
   $ hg clone --stream http://localhost:$HGPORT with-bookmarks
   streaming all changes
   1027 files to transfer, 96.3 KB of data (no-zstd !)
   transferred 96.3 KB in * seconds (*) (glob) (no-zstd !)
   1027 files to transfer, 93.5 KB of data (zstd !)
   transferred 93.5 KB in * seconds (* */sec) (glob) (zstd !)
   searching for changes
   no changes found
   updating to branch default
   1025 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #endif
 #if stream-bundle2
   $ hg clone --stream http://localhost:$HGPORT with-bookmarks
   streaming all changes
   1033 files to transfer, 96.6 KB of data (no-zstd !)
   transferred 96.6 KB in * seconds (* */sec) (glob) (no-zstd !)
   1033 files to transfer, 93.8 KB of data (zstd !)
   transferred 93.8 KB in * seconds (* */sec) (glob) (zstd !)
   updating to branch default
   1025 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #endif
   $ hg -R with-bookmarks bookmarks
      some-bookmark             1:c17445101a72
 
 Stream repository with phases
 -----------------------------
 
 Clone as publishing
 
   $ hg -R server phase -r 'all()'
   0: draft
   1: draft
 
 #if stream-legacy
   $ hg clone --stream http://localhost:$HGPORT phase-publish
   streaming all changes
   1027 files to transfer, 96.3 KB of data (no-zstd !)
   transferred 96.3 KB in * seconds (*) (glob) (no-zstd !)
   1027 files to transfer, 93.5 KB of data (zstd !)
   transferred 93.5 KB in * seconds (* */sec) (glob) (zstd !)
   searching for changes
   no changes found
   updating to branch default
   1025 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #endif
 #if stream-bundle2
   $ hg clone --stream http://localhost:$HGPORT phase-publish
   streaming all changes
   1033 files to transfer, 96.6 KB of data (no-zstd !)
   transferred 96.6 KB in * seconds (* */sec) (glob) (no-zstd !)
   1033 files to transfer, 93.8 KB of data (zstd !)
   transferred 93.8 KB in * seconds (* */sec) (glob) (zstd !)
   updating to branch default
   1025 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #endif
   $ hg -R phase-publish phase -r 'all()'
   0: public
   1: public
 
 Clone as non publishing
 
   $ cat << EOF >> server/.hg/hgrc
   > [phases]
   > publish = False
   > EOF
   $ killdaemons.py
   $ hg -R server serve -p $HGPORT -d --pid-file=hg.pid
   $ cat hg.pid > $DAEMON_PIDS
 
 #if stream-legacy
 
 With v1 of the stream protocol, changeset are always cloned as public. It make
 stream v1 unsuitable for non-publishing repository.
 
   $ hg clone --stream http://localhost:$HGPORT phase-no-publish
   streaming all changes
   1027 files to transfer, 96.3 KB of data (no-zstd !)
   transferred 96.3 KB in * seconds (* */sec) (glob) (no-zstd !)
   1027 files to transfer, 93.5 KB of data (zstd !)
   transferred 93.5 KB in * seconds (* */sec) (glob) (zstd !)
   searching for changes
   no changes found
   updating to branch default
   1025 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R phase-no-publish phase -r 'all()'
   0: public
   1: public
 #endif
 #if stream-bundle2
   $ hg clone --stream http://localhost:$HGPORT phase-no-publish
   streaming all changes
   1034 files to transfer, 96.7 KB of data (no-zstd !)
   transferred 96.7 KB in * seconds (* */sec) (glob) (no-zstd !)
   1034 files to transfer, 93.9 KB of data (zstd !)
   transferred 93.9 KB in * seconds (* */sec) (glob) (zstd !)
   updating to branch default
   1025 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R phase-no-publish phase -r 'all()'
   0: draft
   1: draft
 #endif
 
   $ killdaemons.py
 
 #if stream-legacy
 
 With v1 of the stream protocol, changeset are always cloned as public. There's
 no obsolescence markers exchange in stream v1.
 
 #endif
 #if stream-bundle2
 
 Stream repository with obsolescence
 -----------------------------------
 
 Clone non-publishing with obsolescence
 
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > evolution=all
   > EOF
 
   $ cd server
   $ echo foo > foo
   $ hg -q commit -m 'about to be pruned'
   $ hg debugobsolete `hg log -r . -T '{node}'` -d '0 0' -u test --record-parents
   1 new obsolescence markers
   obsoleted 1 changesets
   $ hg up null -q
   $ hg log -T '{rev}: {phase}\n'
   1: draft
   0: draft
   $ hg serve -p $HGPORT -d --pid-file=hg.pid
   $ cat hg.pid > $DAEMON_PIDS
   $ cd ..
 
   $ hg clone -U --stream http://localhost:$HGPORT with-obsolescence
   streaming all changes
   1035 files to transfer, 97.1 KB of data (no-zstd !)
   transferred 97.1 KB in * seconds (* */sec) (glob) (no-zstd !)
   1035 files to transfer, 94.3 KB of data (zstd !)
   transferred 94.3 KB in * seconds (* */sec) (glob) (zstd !)
   $ hg -R with-obsolescence log -T '{rev}: {phase}\n'
   1: draft
   0: draft
   $ hg debugobsolete -R with-obsolescence
   50382b884f66690b7045cac93a540cba4d4c906f 0 {c17445101a72edac06facd130d14808dfbd5c7c2} (Thu Jan 01 00:00:00 1970 +0000) {'user': 'test'}
 
   $ hg clone -U --stream --config experimental.evolution=0 http://localhost:$HGPORT with-obsolescence-no-evolution
   streaming all changes
   remote: abort: server has obsolescence markers, but client cannot receive them via stream clone
   abort: pull failed on remote
-  [255]
+  [100]
 
   $ killdaemons.py
 
 #endif

tests/test-http.t

@@ -1,617 +1,617 b''
 #require serve
 
   $ hg init test
   $ cd test
   $ echo foo>foo
   $ mkdir foo.d foo.d/bAr.hg.d foo.d/baR.d.hg
   $ echo foo>foo.d/foo
   $ echo bar>foo.d/bAr.hg.d/BaR
   $ echo bar>foo.d/baR.d.hg/bAR
   $ hg commit -A -m 1
   adding foo
   adding foo.d/bAr.hg.d/BaR
   adding foo.d/baR.d.hg/bAR
   adding foo.d/foo
   $ hg serve -p $HGPORT -d --pid-file=../hg1.pid -E ../error.log
   $ hg serve --config server.uncompressed=False -p $HGPORT1 -d --pid-file=../hg2.pid
 
 Test server address cannot be reused
 
   $ hg serve -p $HGPORT1 2>&1
   abort: cannot start server at 'localhost:$HGPORT1': $EADDRINUSE$
   [255]
 
   $ cd ..
   $ cat hg1.pid hg2.pid >> $DAEMON_PIDS
 
 clone via stream
 
 #if no-reposimplestore
   $ hg clone --stream http://localhost:$HGPORT/ copy 2>&1
   streaming all changes
   9 files to transfer, 715 bytes of data (no-zstd !)
   9 files to transfer, 717 bytes of data (zstd !)
   transferred * bytes in * seconds (*/sec) (glob)
   updating to branch default
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg verify -R copy
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 1 changesets with 4 changes to 4 files
 #endif
 
 try to clone via stream, should use pull instead
 
   $ hg clone --stream http://localhost:$HGPORT1/ copy2
   warning: stream clone requested but server has them disabled
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 4 changes to 4 files
   new changesets 8b6053c928fe
   updating to branch default
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 try to clone via stream but missing requirements, so should use pull instead
 
   $ cat > $TESTTMP/removesupportedformat.py << EOF
   > from mercurial import localrepo
   > def extsetup(ui):
   >     localrepo.localrepository.supportedformats.remove(b'generaldelta')
   > EOF
 
   $ hg clone --config extensions.rsf=$TESTTMP/removesupportedformat.py --stream http://localhost:$HGPORT/ copy3
   warning: stream clone requested but client is missing requirements: generaldelta
   (see https://www.mercurial-scm.org/wiki/MissingRequirement for more information)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 4 changes to 4 files
   new changesets 8b6053c928fe
   updating to branch default
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 clone via pull
 
   $ hg clone http://localhost:$HGPORT1/ copy-pull
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 4 changes to 4 files
   new changesets 8b6053c928fe
   updating to branch default
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg verify -R copy-pull
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 1 changesets with 4 changes to 4 files
   $ cd test
   $ echo bar > bar
   $ hg commit -A -d '1 0' -m 2
   adding bar
   $ cd ..
 
 clone over http with --update
 
   $ hg clone http://localhost:$HGPORT1/ updated --update 0
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 5 changes to 5 files
   new changesets 8b6053c928fe:5fed3813f7f5
   updating to branch default
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg log -r . -R updated
   changeset:   0:8b6053c928fe
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1
   
   $ rm -rf updated
 
 incoming via HTTP
 
   $ hg clone http://localhost:$HGPORT1/ --rev 0 partial
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 4 changes to 4 files
   new changesets 8b6053c928fe
   updating to branch default
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd partial
   $ touch LOCAL
   $ hg ci -qAm LOCAL
   $ hg incoming http://localhost:$HGPORT1/ --template '{desc}\n'
   comparing with http://localhost:$HGPORT1/
   searching for changes
   2
   $ cd ..
 
 pull
 
   $ cd copy-pull
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > changegroup = sh -c "printenv.py --line changegroup"
   > EOF
   $ hg pull
   pulling from http://localhost:$HGPORT1/
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets 5fed3813f7f5
   changegroup hook: HG_HOOKNAME=changegroup
   HG_HOOKTYPE=changegroup
   HG_NODE=5fed3813f7f5e1824344fdc9cf8f63bb662c292d
   HG_NODE_LAST=5fed3813f7f5e1824344fdc9cf8f63bb662c292d
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   http://localhost:$HGPORT1/
   HG_URL=http://localhost:$HGPORT1/
   
   (run 'hg update' to get a working copy)
   $ cd ..
 
 clone from invalid URL
 
   $ hg clone http://localhost:$HGPORT/bad
   abort: HTTP Error 404: Not Found
   [100]
 
 test http authentication
 + use the same server to test server side streaming preference
 
   $ cd test
 
   $ hg serve --config extensions.x=$TESTDIR/httpserverauth.py -p $HGPORT2 -d \
   >    --pid-file=pid --config server.preferuncompressed=True -E ../errors2.log \
   >    --config web.push_ssl=False --config web.allow_push=* -A ../access.log
   $ cat pid >> $DAEMON_PIDS
 
   $ cat << EOF > get_pass.py
   > import getpass
   > def newgetpass(arg):
   >   return "pass"
   > getpass.getpass = newgetpass
   > EOF
 
   $ hg id http://localhost:$HGPORT2/
   abort: http authorization required for http://localhost:$HGPORT2/
   [255]
   $ hg id http://localhost:$HGPORT2/
   abort: http authorization required for http://localhost:$HGPORT2/
   [255]
   $ hg id --config ui.interactive=true --debug http://localhost:$HGPORT2/
   using http://localhost:$HGPORT2/
   sending capabilities command
   http authorization required for http://localhost:$HGPORT2/
   realm: mercurial
   user: abort: response expected
   [255]
   $ cat <<'EOF' | hg id --config ui.interactive=true --config ui.nontty=true --debug http://localhost:$HGPORT2/
   > 
   > EOF
   using http://localhost:$HGPORT2/
   sending capabilities command
   http authorization required for http://localhost:$HGPORT2/
   realm: mercurial
   user: 
   password: abort: response expected
   [255]
   $ cat <<'EOF' | hg id --config ui.interactive=true --config ui.nontty=true --debug http://localhost:$HGPORT2/
   > 
   > 
   > EOF
   using http://localhost:$HGPORT2/
   sending capabilities command
   http authorization required for http://localhost:$HGPORT2/
   realm: mercurial
   user: 
   password: abort: authorization failed
   [255]
   $ hg id --config ui.interactive=true --config extensions.getpass=get_pass.py http://user@localhost:$HGPORT2/
   http authorization required for http://localhost:$HGPORT2/
   realm: mercurial
   user: user
   password: 5fed3813f7f5
   $ hg id http://user:pass@localhost:$HGPORT2/
   5fed3813f7f5
   $ echo '[auth]' >> .hg/hgrc
   $ echo 'l.schemes=http' >> .hg/hgrc
   $ echo 'l.prefix=lo' >> .hg/hgrc
   $ echo 'l.username=user' >> .hg/hgrc
   $ echo 'l.password=pass' >> .hg/hgrc
   $ hg id http://localhost:$HGPORT2/
   5fed3813f7f5
   $ hg id http://localhost:$HGPORT2/
   5fed3813f7f5
   $ hg id http://user@localhost:$HGPORT2/
   5fed3813f7f5
 
   $ cat > use_digests.py << EOF
   > from mercurial import (
   >     exthelper,
   >     url,
   > )
   > 
   > eh = exthelper.exthelper()
   > uisetup = eh.finaluisetup
   > 
   > @eh.wrapfunction(url, 'opener')
   > def urlopener(orig, *args, **kwargs):
   >     opener = orig(*args, **kwargs)
   >     opener.addheaders.append((r'X-HgTest-AuthType', r'Digest'))
   >     return opener
   > EOF
 
   $ hg id http://localhost:$HGPORT2/ --config extensions.x=use_digests.py
   5fed3813f7f5
 
 #if no-reposimplestore
   $ hg clone http://user:pass@localhost:$HGPORT2/ dest 2>&1
   streaming all changes
   10 files to transfer, 1.01 KB of data
   transferred * KB in * seconds (*/sec) (glob)
   updating to branch default
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #endif
 
 --pull should override server's preferuncompressed
   $ hg clone --pull http://user:pass@localhost:$HGPORT2/ dest-pull 2>&1
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 5 changes to 5 files
   new changesets 8b6053c928fe:5fed3813f7f5
   updating to branch default
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg id http://user2@localhost:$HGPORT2/
   abort: http authorization required for http://localhost:$HGPORT2/
   [255]
   $ hg id http://user:pass2@localhost:$HGPORT2/
   abort: HTTP Error 403: no
   [100]
 
   $ hg -R dest-pull tag -r tip top
   $ hg -R dest-pull push http://user:pass@localhost:$HGPORT2/
   pushing to http://user:***@localhost:$HGPORT2/
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 1 changesets with 1 changes to 1 files
   $ hg rollback -q
   $ hg -R dest-pull push http://user:pass@localhost:$HGPORT2/ --debug --config devel.debug.peer-request=yes
   pushing to http://user:***@localhost:$HGPORT2/
   using http://localhost:$HGPORT2/
   http auth: user user, password ****
   sending capabilities command
   devel-peer-request: GET http://localhost:$HGPORT2/?cmd=capabilities
   http auth: user user, password ****
   devel-peer-request:   finished in *.???? seconds (200) (glob)
   query 1; heads
   devel-peer-request: batched-content
   devel-peer-request:    - heads (0 arguments)
   devel-peer-request:    - known (1 arguments)
   sending batch command
   devel-peer-request: GET http://localhost:$HGPORT2/?cmd=batch
   devel-peer-request:   Vary X-HgArg-1,X-HgProto-1
   devel-peer-request:   X-hgproto-1 0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   devel-peer-request:   68 bytes of commands arguments in headers
   devel-peer-request:   finished in *.???? seconds (200) (glob)
   searching for changes
   all remote heads known locally
   preparing listkeys for "phases"
   sending listkeys command
   devel-peer-request: GET http://localhost:$HGPORT2/?cmd=listkeys
   devel-peer-request:   Vary X-HgArg-1,X-HgProto-1
   devel-peer-request:   X-hgproto-1 0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   devel-peer-request:   16 bytes of commands arguments in headers
   devel-peer-request:   finished in *.???? seconds (200) (glob)
   received listkey for "phases": 58 bytes
   checking for updated bookmarks
   preparing listkeys for "bookmarks"
   sending listkeys command
   devel-peer-request: GET http://localhost:$HGPORT2/?cmd=listkeys
   devel-peer-request:   Vary X-HgArg-1,X-HgProto-1
   devel-peer-request:   X-hgproto-1 0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   devel-peer-request:   19 bytes of commands arguments in headers
   devel-peer-request:   finished in *.???? seconds (200) (glob)
   received listkey for "bookmarks": 0 bytes
   sending branchmap command
   devel-peer-request: GET http://localhost:$HGPORT2/?cmd=branchmap
   devel-peer-request:   Vary X-HgProto-1
   devel-peer-request:   X-hgproto-1 0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   devel-peer-request:   finished in *.???? seconds (200) (glob)
   preparing listkeys for "bookmarks"
   sending listkeys command
   devel-peer-request: GET http://localhost:$HGPORT2/?cmd=listkeys
   devel-peer-request:   Vary X-HgArg-1,X-HgProto-1
   devel-peer-request:   X-hgproto-1 0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   devel-peer-request:   19 bytes of commands arguments in headers
   devel-peer-request:   finished in *.???? seconds (200) (glob)
   received listkey for "bookmarks": 0 bytes
   1 changesets found
   list of changesets:
   7f4e523d01f2cc3765ac8934da3d14db775ff872
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 207 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:updated-heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   sending unbundle command
   sending 1023 bytes
   devel-peer-request: POST http://localhost:$HGPORT2/?cmd=unbundle
   devel-peer-request:   Content-length 1023
   devel-peer-request:   Content-type application/mercurial-0.1
   devel-peer-request:   Vary X-HgArg-1,X-HgProto-1
   devel-peer-request:   X-hgproto-1 0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   devel-peer-request:   16 bytes of commands arguments in headers
   devel-peer-request:   1023 bytes of data
   devel-peer-request:   finished in *.???? seconds (200) (glob)
   bundle2-input-bundle: no-transaction
   bundle2-input-part: "reply:changegroup" (advisory) (params: 0 advisory) supported
   bundle2-input-part: "output" (advisory) (params: 0 advisory) supported
   bundle2-input-part: total payload size 55
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   bundle2-input-part: "output" (advisory) supported
   bundle2-input-part: total payload size 45
   remote: added 1 changesets with 1 changes to 1 files
   bundle2-input-bundle: 3 parts total
   preparing listkeys for "phases"
   sending listkeys command
   devel-peer-request: GET http://localhost:$HGPORT2/?cmd=listkeys
   devel-peer-request:   Vary X-HgArg-1,X-HgProto-1
   devel-peer-request:   X-hgproto-1 0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   devel-peer-request:   16 bytes of commands arguments in headers
   devel-peer-request:   finished in *.???? seconds (200) (glob)
   received listkey for "phases": 15 bytes
   (sent 9 HTTP requests and * bytes; received * bytes in responses) (glob) (?)
   $ hg rollback -q
 
   $ sed 's/.*] "/"/' < ../access.log
   "GET /?cmd=capabilities HTTP/1.1" 401 -
   "GET /?cmd=capabilities HTTP/1.1" 401 -
   "GET /?cmd=capabilities HTTP/1.1" 401 -
   "GET /?cmd=capabilities HTTP/1.1" 401 -
   "GET /?cmd=capabilities HTTP/1.1" 401 -
   "GET /?cmd=capabilities HTTP/1.1" 401 -
   "GET /?cmd=capabilities HTTP/1.1" 200 -
   "GET /?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=tip x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=namespaces x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=bookmarks x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=capabilities HTTP/1.1" 401 -
   "GET /?cmd=capabilities HTTP/1.1" 200 -
   "GET /?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=tip x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=namespaces x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=bookmarks x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=capabilities HTTP/1.1" 401 -
   "GET /?cmd=capabilities HTTP/1.1" 200 -
   "GET /?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=tip x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=namespaces x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=bookmarks x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=capabilities HTTP/1.1" 401 -
   "GET /?cmd=capabilities HTTP/1.1" 200 -
   "GET /?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=tip x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=namespaces x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=bookmarks x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=capabilities HTTP/1.1" 401 -
   "GET /?cmd=capabilities HTTP/1.1" 200 -
   "GET /?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=tip x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=namespaces x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=bookmarks x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=capabilities HTTP/1.1" 401 - x-hgtest-authtype:Digest
   "GET /?cmd=capabilities HTTP/1.1" 200 - x-hgtest-authtype:Digest
   "GET /?cmd=lookup HTTP/1.1" 401 - x-hgarg-1:key=tip x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull x-hgtest-authtype:Digest
   "GET /?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=tip x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull x-hgtest-authtype:Digest
   "GET /?cmd=listkeys HTTP/1.1" 401 - x-hgarg-1:namespace=namespaces x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull x-hgtest-authtype:Digest
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=namespaces x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull x-hgtest-authtype:Digest
   "GET /?cmd=listkeys HTTP/1.1" 401 - x-hgarg-1:namespace=bookmarks x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull x-hgtest-authtype:Digest
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=bookmarks x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull x-hgtest-authtype:Digest
   "GET /?cmd=capabilities HTTP/1.1" 401 - (no-reposimplestore !)
   "GET /?cmd=capabilities HTTP/1.1" 200 - (no-reposimplestore !)
   "GET /?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=heads+%3Bknown+nodes%3D x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull (no-reposimplestore !)
   "GET /?cmd=getbundle HTTP/1.1" 200 - x-hgarg-1:bookmarks=1&$USUAL_BUNDLE_CAPS$&cg=0&common=0000000000000000000000000000000000000000&heads=5fed3813f7f5e1824344fdc9cf8f63bb662c292d&listkeys=bookmarks&stream=1 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull (no-reposimplestore !)
   "GET /?cmd=capabilities HTTP/1.1" 401 - (no-reposimplestore !)
   "GET /?cmd=capabilities HTTP/1.1" 200 - (no-reposimplestore !)
   "GET /?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=heads+%3Bknown+nodes%3D x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=getbundle HTTP/1.1" 200 - x-hgarg-1:bookmarks=1&$USUAL_BUNDLE_CAPS$&cg=1&common=0000000000000000000000000000000000000000&heads=5fed3813f7f5e1824344fdc9cf8f63bb662c292d&listkeys=bookmarks&phases=1 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=capabilities HTTP/1.1" 401 -
   "GET /?cmd=capabilities HTTP/1.1" 401 -
   "GET /?cmd=capabilities HTTP/1.1" 403 -
   "GET /?cmd=capabilities HTTP/1.1" 401 -
   "GET /?cmd=capabilities HTTP/1.1" 200 -
   "GET /?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=heads+%3Bknown+nodes%3D7f4e523d01f2cc3765ac8934da3d14db775ff872 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=phases x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=bookmarks x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=branchmap HTTP/1.1" 200 - x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=bookmarks x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "POST /?cmd=unbundle HTTP/1.1" 200 - x-hgarg-1:heads=666f726365* (glob)
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=phases x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=capabilities HTTP/1.1" 401 -
   "GET /?cmd=capabilities HTTP/1.1" 200 -
   "GET /?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=heads+%3Bknown+nodes%3D7f4e523d01f2cc3765ac8934da3d14db775ff872 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=phases x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=bookmarks x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=branchmap HTTP/1.1" 200 - x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=bookmarks x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "POST /?cmd=unbundle HTTP/1.1" 200 - x-hgarg-1:heads=666f726365 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
   "GET /?cmd=listkeys HTTP/1.1" 200 - x-hgarg-1:namespace=phases x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull
 
   $ cd ..
 
 clone of serve with repo in root and unserved subrepo (issue2970)
 
   $ hg --cwd test init sub
   $ echo empty > test/sub/empty
   $ hg --cwd test/sub add empty
   $ hg --cwd test/sub commit -qm 'add empty'
   $ hg --cwd test/sub tag -r 0 something
   $ echo sub = sub > test/.hgsub
   $ hg --cwd test add .hgsub
   $ hg --cwd test commit -qm 'add subrepo'
   $ hg clone http://localhost:$HGPORT noslash-clone
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 7 changes to 7 files
   new changesets 8b6053c928fe:56f9bc90cce6
   updating to branch default
   cloning subrepo sub from http://localhost:$HGPORT/sub
   abort: HTTP Error 404: Not Found
   [100]
   $ hg clone http://localhost:$HGPORT/ slash-clone
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 7 changes to 7 files
   new changesets 8b6053c928fe:56f9bc90cce6
   updating to branch default
   cloning subrepo sub from http://localhost:$HGPORT/sub
   abort: HTTP Error 404: Not Found
   [100]
 
 check error log
 
   $ cat error.log
 
   $ cat errors2.log
 
 check abort error reporting while pulling/cloning
 
   $ $RUNTESTDIR/killdaemons.py
   $ hg serve -R test -p $HGPORT -d --pid-file=hg3.pid -E error.log --config extensions.crash=${TESTDIR}/crashgetbundler.py
   $ cat hg3.pid >> $DAEMON_PIDS
   $ hg clone http://localhost:$HGPORT/ abort-clone
   requesting all changes
   remote: abort: this is an exercise
   abort: pull failed on remote
-  [255]
+  [100]
   $ cat error.log
 
 disable pull-based clones
 
   $ hg serve -R test -p $HGPORT1 -d --pid-file=hg4.pid -E error.log --config server.disablefullbundle=True
   $ cat hg4.pid >> $DAEMON_PIDS
   $ hg clone http://localhost:$HGPORT1/ disable-pull-clone
   requesting all changes
   remote: abort: server has pull-based clones disabled
   abort: pull failed on remote
   (remove --pull if specified or upgrade Mercurial)
-  [255]
+  [100]
 
 #if no-reposimplestore
 ... but keep stream clones working
 
   $ hg clone --stream --noupdate http://localhost:$HGPORT1/ test-stream-clone
   streaming all changes
   * files to transfer, * of data (glob)
   transferred * in * seconds (*/sec) (glob)
   $ cat error.log
 #endif
 
 ... and also keep partial clones and pulls working
   $ hg clone http://localhost:$HGPORT1 --rev 0 test/partial/clone
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 4 changes to 4 files
   new changesets 8b6053c928fe
   updating to branch default
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg pull -R test/partial/clone
   pulling from http://localhost:$HGPORT1/
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 3 changes to 3 files
   new changesets 5fed3813f7f5:56f9bc90cce6
   (run 'hg update' to get a working copy)
 
   $ hg clone -U -r 0 test/partial/clone test/another/clone
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 4 changes to 4 files
   new changesets 8b6053c928fe
 
 corrupt cookies file should yield a warning
 
   $ cat > $TESTTMP/cookies.txt << EOF
   > bad format
   > EOF
 
   $ hg --config auth.cookiefile=$TESTTMP/cookies.txt id http://localhost:$HGPORT/
   (error loading cookie file $TESTTMP/cookies.txt: '*/cookies.txt' does not look like a Netscape format cookies file; continuing without cookies) (glob)
   56f9bc90cce6
 
   $ killdaemons.py
 
 Create dummy authentication handler that looks for cookies. It doesn't do anything
 useful. It just raises an HTTP 500 with details about the Cookie request header.
 We raise HTTP 500 because its message is printed in the abort message.
 
   $ cat > cookieauth.py << EOF
   > from mercurial import util
   > from mercurial.hgweb import common
   > def perform_authentication(hgweb, req, op):
   >     cookie = req.headers.get(b'Cookie')
   >     if not cookie:
   >         raise common.ErrorResponse(common.HTTP_SERVER_ERROR, b'no-cookie')
   >     raise common.ErrorResponse(common.HTTP_SERVER_ERROR, b'Cookie: %s' % cookie)
   > def extsetup(ui):
   >     common.permhooks.insert(0, perform_authentication)
   > EOF
 
   $ hg serve --config extensions.cookieauth=cookieauth.py -R test -p $HGPORT -d --pid-file=pid
   $ cat pid > $DAEMON_PIDS
 
 Request without cookie sent should fail due to lack of cookie
 
   $ hg id http://localhost:$HGPORT
   abort: HTTP Error 500: no-cookie
   [100]
 
 Populate a cookies file
 
   $ cat > cookies.txt << EOF
   > # HTTP Cookie File
   > # Expiration is 2030-01-01 at midnight
   > .example.com	TRUE	/	FALSE	1893456000	hgkey	examplevalue
   > EOF
 
 Should not send a cookie for another domain
 
   $ hg --config auth.cookiefile=cookies.txt id http://localhost:$HGPORT/
   abort: HTTP Error 500: no-cookie
   [100]
 
 Add a cookie entry for our test server and verify it is sent
 
   $ cat >> cookies.txt << EOF
   > localhost.local	FALSE	/	FALSE	1893456000	hgkey	localhostvalue
   > EOF
 
   $ hg --config auth.cookiefile=cookies.txt id http://localhost:$HGPORT/
   abort: HTTP Error 500: Cookie: hgkey=localhostvalue
   [100]

tests/test-lfs-serve.t

@@ -1,694 +1,694 b''
 #testcases lfsremote-on lfsremote-off
 #require serve no-reposimplestore no-chg
 
 This test splits `hg serve` with and without using the extension into separate
 tests cases.  The tests are broken down as follows, where "LFS"/"No-LFS"
 indicates whether or not there are commits that use an LFS file, and "D"/"E"
 indicates whether or not the extension is loaded.  The "X" cases are not tested
 individually, because the lfs requirement causes the process to bail early if
 the extension is disabled.
 
 .                        Server
 .
 .                    No-LFS        LFS
 .            +----------------------------+
 .            |   ||  D  |  E  |  D  |  E  |
 .            |---++=======================|
 .  C         | D || N/A | #1  |  X  | #4  |
 .  l    No   +---++-----------------------|
 .  i    LFS  | E || #2  | #2  |  X  | #5  |
 .  e         +---++-----------------------|
 .  n         | D ||  X  |  X  |  X  |  X  |
 .  t    LFS  |---++-----------------------|
 .            | E || #3  | #3  |  X  | #6  |
 .            |---++-----------------------+
 
 make command server magic visible
 
 #if windows
   $ PYTHONPATH="$TESTDIR/../contrib;$PYTHONPATH"
 #else
   $ PYTHONPATH="$TESTDIR/../contrib:$PYTHONPATH"
 #endif
   $ export PYTHONPATH
 
   $ hg init server
   $ SERVER_REQUIRES="$TESTTMP/server/.hg/requires"
 
   $ cat > $TESTTMP/debugprocessors.py <<EOF
   > from mercurial import (
   >     cmdutil,
   >     commands,
   >     pycompat,
   >     registrar,
   > )
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > @command(b'debugprocessors', [], b'FILE')
   > def debugprocessors(ui, repo, file_=None, **opts):
   >     opts = pycompat.byteskwargs(opts)
   >     opts[b'changelog'] = False
   >     opts[b'manifest'] = False
   >     opts[b'dir'] = False
   >     rl = cmdutil.openrevlog(repo, b'debugprocessors', file_, opts)
   >     for flag, proc in rl._flagprocessors.items():
   >         ui.status(b"registered processor '%#x'\n" % (flag))
   > EOF
 
 Skip the experimental.changegroup3=True config.  Failure to agree on this comes
 first, and causes an "abort: no common changegroup version" if the extension is
 only loaded on one side. If that *is* enabled, the subsequent failure is "abort:
 missing processor for flag '0x2000'!" if the extension is only loaded on one side
 (possibly also masked by the Internal Server Error message).
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > debugprocessors = $TESTTMP/debugprocessors.py
   > [experimental]
   > lfs.disableusercache = True
   > lfs.worker-enable = False
   > [lfs]
   > threshold=10
   > [web]
   > allow_push=*
   > push_ssl=False
   > EOF
 
   $ cp $HGRCPATH $HGRCPATH.orig
 
 #if lfsremote-on
   $ hg --config extensions.lfs= -R server \
   >    serve -p $HGPORT -d --pid-file=hg.pid --errorlog=$TESTTMP/errors.log
 #else
   $ hg --config extensions.lfs=! -R server \
   >    serve -p $HGPORT -d --pid-file=hg.pid --errorlog=$TESTTMP/errors.log
 #endif
 
   $ cat hg.pid >> $DAEMON_PIDS
   $ hg clone -q http://localhost:$HGPORT client
   $ grep 'lfs' client/.hg/requires $SERVER_REQUIRES
   [1]
 
 This trivial repo will force commandserver to load the extension, but not call
 reposetup() on another repo actually being operated on.  This gives coverage
 that wrapper functions are not assuming reposetup() was called.
 
   $ hg init $TESTTMP/cmdservelfs
   $ cat >> $TESTTMP/cmdservelfs/.hg/hgrc << EOF
   > [extensions]
   > lfs =
   > EOF
 
 --------------------------------------------------------------------------------
 Case #1: client with non-lfs content and the extension disabled; server with
 non-lfs content, and the extension enabled.
 
   $ cd client
   $ echo 'non-lfs' > nonlfs.txt
   >>> from __future__ import absolute_import
   >>> from hgclient import check, readchannel, runcommand
   >>> @check
   ... def diff(server):
   ...     readchannel(server)
   ...     # run an arbitrary command in the repo with the extension loaded
   ...     runcommand(server, [b'id', b'-R', b'../cmdservelfs'])
   ...     # now run a command in a repo without the extension to ensure that
   ...     # files are added safely..
   ...     runcommand(server, [b'ci', b'-Aqm', b'non-lfs'])
   ...     # .. and that scmutil.prefetchfiles() safely no-ops..
   ...     runcommand(server, [b'diff', b'-r', b'.~1'])
   ...     # .. and that debugupgraderepo safely no-ops.
   ...     runcommand(server, [b'debugupgraderepo', b'-q', b'--run'])
   *** runcommand id -R ../cmdservelfs
   000000000000 tip
   *** runcommand ci -Aqm non-lfs
   *** runcommand diff -r .~1
   diff -r 000000000000 nonlfs.txt
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/nonlfs.txt	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +non-lfs
   *** runcommand debugupgraderepo -q --run
 
   $ grep 'lfs' .hg/requires $SERVER_REQUIRES
   [1]
 
 #if lfsremote-on
 
   $ hg push -q
   $ grep 'lfs' .hg/requires $SERVER_REQUIRES
   [1]
 
   $ hg clone -q http://localhost:$HGPORT $TESTTMP/client1_clone
   $ grep 'lfs' $TESTTMP/client1_clone/.hg/requires $SERVER_REQUIRES
   [1]
 
   $ hg init $TESTTMP/client1_pull
   $ hg -R $TESTTMP/client1_pull pull -q http://localhost:$HGPORT
   $ grep 'lfs' $TESTTMP/client1_pull/.hg/requires $SERVER_REQUIRES
   [1]
 
   $ hg identify http://localhost:$HGPORT
   d437e1d24fbd
 
 #endif
 
 --------------------------------------------------------------------------------
 Case #2: client with non-lfs content and the extension enabled; server with
 non-lfs content, and the extension state controlled by #testcases.
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > lfs =
   > EOF
   $ echo 'non-lfs' > nonlfs2.txt
   $ hg ci -Aqm 'non-lfs file with lfs client'
 
 Since no lfs content has been added yet, the push is allowed, even when the
 extension is not enabled remotely.
 
   $ hg push -q
   $ grep 'lfs' .hg/requires $SERVER_REQUIRES
   [1]
 
   $ hg clone -q http://localhost:$HGPORT $TESTTMP/client2_clone
   $ grep 'lfs' $TESTTMP/client2_clone/.hg/requires $SERVER_REQUIRES
   [1]
 
   $ hg init $TESTTMP/client2_pull
   $ hg -R $TESTTMP/client2_pull pull -q http://localhost:$HGPORT
   $ grep 'lfs' $TESTTMP/client2_pull/.hg/requires $SERVER_REQUIRES
   [1]
 
   $ hg identify http://localhost:$HGPORT
   1477875038c6
 
 --------------------------------------------------------------------------------
 Case #3: client with lfs content and the extension enabled; server with
 non-lfs content, and the extension state controlled by #testcases.  The server
 should have an 'lfs' requirement after it picks up its first commit with a blob.
 
   $ echo 'this is a big lfs file' > lfs.bin
   $ hg ci -Aqm 'lfs'
   $ grep 'lfs' .hg/requires $SERVER_REQUIRES
   .hg/requires:lfs
 
 #if lfsremote-off
   $ hg push -q
   abort: required features are not supported in the destination: lfs
   (enable the lfs extension on the server)
   [255]
 #else
   $ hg push -q
 #endif
   $ grep 'lfs' .hg/requires $SERVER_REQUIRES
   .hg/requires:lfs
   $TESTTMP/server/.hg/requires:lfs (lfsremote-on !)
 
   $ hg clone -q http://localhost:$HGPORT $TESTTMP/client3_clone
   $ grep 'lfs' $TESTTMP/client3_clone/.hg/requires $SERVER_REQUIRES || true
   $TESTTMP/client3_clone/.hg/requires:lfs (lfsremote-on !)
   $TESTTMP/server/.hg/requires:lfs (lfsremote-on !)
 
   $ hg init $TESTTMP/client3_pull
   $ hg -R $TESTTMP/client3_pull pull -q http://localhost:$HGPORT
   $ grep 'lfs' $TESTTMP/client3_pull/.hg/requires $SERVER_REQUIRES || true
   $TESTTMP/client3_pull/.hg/requires:lfs (lfsremote-on !)
   $TESTTMP/server/.hg/requires:lfs (lfsremote-on !)
 
 Test that the commit/changegroup requirement check hook can be run multiple
 times.
 
   $ hg clone -qr 0 http://localhost:$HGPORT $TESTTMP/cmdserve_client3
 
   $ cd ../cmdserve_client3
 
   >>> from __future__ import absolute_import
   >>> from hgclient import check, readchannel, runcommand
   >>> @check
   ... def addrequirement(server):
   ...     readchannel(server)
   ...     # change the repo in a way that adds the lfs requirement
   ...     runcommand(server, [b'pull', b'-qu'])
   ...     # Now cause the requirement adding hook to fire again, without going
   ...     # through reposetup() again.
   ...     with open('file.txt', 'wb') as fp:
   ...         fp.write(b'data')
   ...     runcommand(server, [b'ci', b'-Aqm', b'non-lfs'])
   *** runcommand pull -qu
   *** runcommand ci -Aqm non-lfs
 
   $ cd ../client
 
 The difference here is the push failed above when the extension isn't
 enabled on the server.
   $ hg identify http://localhost:$HGPORT
   8374dc4052cb (lfsremote-on !)
   1477875038c6 (lfsremote-off !)
 
 Don't bother testing the lfsremote-off cases- the server won't be able
 to launch if there's lfs content and the extension is disabled.
 
 #if lfsremote-on
 
 --------------------------------------------------------------------------------
 Case #4: client with non-lfs content and the extension disabled; server with
 lfs content, and the extension enabled.
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > lfs = !
   > EOF
 
   $ hg init $TESTTMP/client4
   $ cd $TESTTMP/client4
   $ cat >> .hg/hgrc <<EOF
   > [paths]
   > default = http://localhost:$HGPORT
   > EOF
   $ echo 'non-lfs' > nonlfs2.txt
   $ hg ci -Aqm 'non-lfs'
   $ grep 'lfs' .hg/requires $SERVER_REQUIRES
   $TESTTMP/server/.hg/requires:lfs
 
   $ hg push -q --force
   warning: repository is unrelated
   $ grep 'lfs' .hg/requires $SERVER_REQUIRES
   $TESTTMP/server/.hg/requires:lfs
 
   $ hg clone http://localhost:$HGPORT $TESTTMP/client4_clone
   (remote is using large file support (lfs), but it is explicitly disabled in the local configuration)
   abort: repository requires features unknown to this Mercurial: lfs
   (see https://mercurial-scm.org/wiki/MissingRequirement for more information)
   [255]
   $ grep 'lfs' $TESTTMP/client4_clone/.hg/requires $SERVER_REQUIRES
   grep: $TESTTMP/client4_clone/.hg/requires: $ENOENT$
   $TESTTMP/server/.hg/requires:lfs
   [2]
 
 TODO: fail more gracefully.
 
   $ hg init $TESTTMP/client4_pull
   $ hg -R $TESTTMP/client4_pull pull http://localhost:$HGPORT
   pulling from http://localhost:$HGPORT/
   requesting all changes
   remote: abort: no common changegroup version
   abort: pull failed on remote
-  [255]
+  [100]
   $ grep 'lfs' $TESTTMP/client4_pull/.hg/requires $SERVER_REQUIRES
   $TESTTMP/server/.hg/requires:lfs
 
   $ hg identify http://localhost:$HGPORT
   03b080fa9d93
 
 --------------------------------------------------------------------------------
 Case #5: client with non-lfs content and the extension enabled; server with
 lfs content, and the extension enabled.
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > lfs =
   > EOF
   $ echo 'non-lfs' > nonlfs3.txt
   $ hg ci -Aqm 'non-lfs file with lfs client'
 
   $ hg push -q
   $ grep 'lfs' .hg/requires $SERVER_REQUIRES
   $TESTTMP/server/.hg/requires:lfs
 
   $ hg clone -q http://localhost:$HGPORT $TESTTMP/client5_clone
   $ grep 'lfs' $TESTTMP/client5_clone/.hg/requires $SERVER_REQUIRES
   $TESTTMP/client5_clone/.hg/requires:lfs
   $TESTTMP/server/.hg/requires:lfs
 
   $ hg init $TESTTMP/client5_pull
   $ hg -R $TESTTMP/client5_pull pull -q http://localhost:$HGPORT
   $ grep 'lfs' $TESTTMP/client5_pull/.hg/requires $SERVER_REQUIRES
   $TESTTMP/client5_pull/.hg/requires:lfs
   $TESTTMP/server/.hg/requires:lfs
 
   $ hg identify http://localhost:$HGPORT
   c729025cc5e3
 
   $ mv $HGRCPATH $HGRCPATH.tmp
   $ cp $HGRCPATH.orig $HGRCPATH
 
   >>> from __future__ import absolute_import
   >>> from hgclient import bprint, check, readchannel, runcommand, stdout
   >>> @check
   ... def checkflags(server):
   ...     readchannel(server)
   ...     bprint(b'')
   ...     bprint(b'# LFS required- both lfs and non-lfs revlogs have 0x2000 flag')
   ...     stdout.flush()
   ...     runcommand(server, [b'debugprocessors', b'lfs.bin', b'-R',
   ...                b'../server'])
   ...     runcommand(server, [b'debugprocessors', b'nonlfs2.txt', b'-R',
   ...                b'../server'])
   ...     runcommand(server, [b'config', b'extensions', b'--cwd',
   ...                b'../server'])
   ... 
   ...     bprint(b"\n# LFS not enabled- revlogs don't have 0x2000 flag")
   ...     stdout.flush()
   ...     runcommand(server, [b'debugprocessors', b'nonlfs3.txt'])
   ...     runcommand(server, [b'config', b'extensions'])
   
   # LFS required- both lfs and non-lfs revlogs have 0x2000 flag
   *** runcommand debugprocessors lfs.bin -R ../server
   registered processor '0x8000'
   registered processor '0x800'
   registered processor '0x2000'
   *** runcommand debugprocessors nonlfs2.txt -R ../server
   registered processor '0x8000'
   registered processor '0x800'
   registered processor '0x2000'
   *** runcommand config extensions --cwd ../server
   extensions.debugprocessors=$TESTTMP/debugprocessors.py
   extensions.lfs=
   
   # LFS not enabled- revlogs don't have 0x2000 flag
   *** runcommand debugprocessors nonlfs3.txt
   registered processor '0x8000'
   registered processor '0x800'
   *** runcommand config extensions
   extensions.debugprocessors=$TESTTMP/debugprocessors.py
 
   $ rm $HGRCPATH
   $ mv $HGRCPATH.tmp $HGRCPATH
 
   $ hg clone $TESTTMP/client $TESTTMP/nonlfs -qr 0 --config extensions.lfs=
   $ cat >> $TESTTMP/nonlfs/.hg/hgrc <<EOF
   > [extensions]
   > lfs = !
   > EOF
 
   >>> from __future__ import absolute_import, print_function
   >>> from hgclient import bprint, check, readchannel, runcommand, stdout
   >>> @check
   ... def checkflags2(server):
   ...     readchannel(server)
   ...     bprint(b'')
   ...     bprint(b'# LFS enabled- both lfs and non-lfs revlogs have 0x2000 flag')
   ...     stdout.flush()
   ...     runcommand(server, [b'debugprocessors', b'lfs.bin', b'-R',
   ...                b'../server'])
   ...     runcommand(server, [b'debugprocessors', b'nonlfs2.txt', b'-R',
   ...                b'../server'])
   ...     runcommand(server, [b'config', b'extensions', b'--cwd',
   ...                b'../server'])
   ... 
   ...     bprint(b'\n# LFS enabled without requirement- revlogs have 0x2000 flag')
   ...     stdout.flush()
   ...     runcommand(server, [b'debugprocessors', b'nonlfs3.txt'])
   ...     runcommand(server, [b'config', b'extensions'])
   ... 
   ...     bprint(b"\n# LFS disabled locally- revlogs don't have 0x2000 flag")
   ...     stdout.flush()
   ...     runcommand(server, [b'debugprocessors', b'nonlfs.txt', b'-R',
   ...                b'../nonlfs'])
   ...     runcommand(server, [b'config', b'extensions', b'--cwd',
   ...                b'../nonlfs'])
   
   # LFS enabled- both lfs and non-lfs revlogs have 0x2000 flag
   *** runcommand debugprocessors lfs.bin -R ../server
   registered processor '0x8000'
   registered processor '0x800'
   registered processor '0x2000'
   *** runcommand debugprocessors nonlfs2.txt -R ../server
   registered processor '0x8000'
   registered processor '0x800'
   registered processor '0x2000'
   *** runcommand config extensions --cwd ../server
   extensions.debugprocessors=$TESTTMP/debugprocessors.py
   extensions.lfs=
   
   # LFS enabled without requirement- revlogs have 0x2000 flag
   *** runcommand debugprocessors nonlfs3.txt
   registered processor '0x8000'
   registered processor '0x800'
   registered processor '0x2000'
   *** runcommand config extensions
   extensions.debugprocessors=$TESTTMP/debugprocessors.py
   extensions.lfs=
   
   # LFS disabled locally- revlogs don't have 0x2000 flag
   *** runcommand debugprocessors nonlfs.txt -R ../nonlfs
   registered processor '0x8000'
   registered processor '0x800'
   *** runcommand config extensions --cwd ../nonlfs
   extensions.debugprocessors=$TESTTMP/debugprocessors.py
   extensions.lfs=!
 
 --------------------------------------------------------------------------------
 Case #6: client with lfs content and the extension enabled; server with
 lfs content, and the extension enabled.
 
   $ echo 'this is another lfs file' > lfs2.txt
   $ hg ci -Aqm 'lfs file with lfs client'
 
   $ hg --config paths.default= push -v http://localhost:$HGPORT
   pushing to http://localhost:$HGPORT/
   lfs: assuming remote store: http://localhost:$HGPORT/.git/info/lfs
   searching for changes
   remote has heads on branch 'default' that are not known locally: 8374dc4052cb
   lfs: uploading a82f1c5cea0d40e3bb3a849686bb4e6ae47ca27e614de55c1ed0325698ef68de (25 bytes)
   lfs: processed: a82f1c5cea0d40e3bb3a849686bb4e6ae47ca27e614de55c1ed0325698ef68de
   lfs: uploaded 1 files (25 bytes)
   1 changesets found
   uncompressed size of bundle content:
        206 (changelog)
        172 (manifests)
        275  lfs2.txt
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 1 changesets with 1 changes to 1 files
   (sent 8 HTTP requests and * bytes; received * bytes in responses) (glob) (?)
   $ grep 'lfs' .hg/requires $SERVER_REQUIRES
   .hg/requires:lfs
   $TESTTMP/server/.hg/requires:lfs
 
   $ hg clone -q http://localhost:$HGPORT $TESTTMP/client6_clone
   $ grep 'lfs' $TESTTMP/client6_clone/.hg/requires $SERVER_REQUIRES
   $TESTTMP/client6_clone/.hg/requires:lfs
   $TESTTMP/server/.hg/requires:lfs
 
   $ hg init $TESTTMP/client6_pull
   $ hg -R $TESTTMP/client6_pull pull -u -v http://localhost:$HGPORT
   pulling from http://localhost:$HGPORT/
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   calling hook pretxnchangegroup.lfs: hgext.lfs.checkrequireslfs
   added 6 changesets with 5 changes to 5 files (+1 heads)
   new changesets d437e1d24fbd:d3b84d50eacb
   resolving manifests
   lfs: assuming remote store: http://localhost:$HGPORT/.git/info/lfs
   lfs: downloading a82f1c5cea0d40e3bb3a849686bb4e6ae47ca27e614de55c1ed0325698ef68de (25 bytes)
   lfs: processed: a82f1c5cea0d40e3bb3a849686bb4e6ae47ca27e614de55c1ed0325698ef68de
   lfs: downloaded 1 files (25 bytes)
   getting lfs2.txt
   lfs: found a82f1c5cea0d40e3bb3a849686bb4e6ae47ca27e614de55c1ed0325698ef68de in the local lfs store
   getting nonlfs2.txt
   getting nonlfs3.txt
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updated to "d3b84d50eacb: lfs file with lfs client"
   1 other heads for branch "default"
   (sent 3 HTTP requests and * bytes; received * bytes in responses) (glob)
   $ grep 'lfs' $TESTTMP/client6_pull/.hg/requires $SERVER_REQUIRES
   $TESTTMP/client6_pull/.hg/requires:lfs
   $TESTTMP/server/.hg/requires:lfs
 
   $ hg identify http://localhost:$HGPORT
   d3b84d50eacb
 
 --------------------------------------------------------------------------------
 Misc: process dies early if a requirement exists and the extension is disabled
 
   $ hg --config extensions.lfs=! summary
   abort: repository requires features unknown to this Mercurial: lfs
   (see https://mercurial-scm.org/wiki/MissingRequirement for more information)
   [255]
 
   $ echo 'this is an lfs file' > $TESTTMP/client6_clone/lfspair1.bin
   $ echo 'this is an lfs file too' > $TESTTMP/client6_clone/lfspair2.bin
   $ hg -R $TESTTMP/client6_clone ci -Aqm 'add lfs pair'
   $ hg -R $TESTTMP/client6_clone push -q
 
   $ hg clone -qU http://localhost:$HGPORT $TESTTMP/bulkfetch
 
 Cat doesn't prefetch unless data is needed (e.g. '-T {rawdata}' doesn't need it)
 
   $ hg --cwd $TESTTMP/bulkfetch cat -vr tip lfspair1.bin -T '{rawdata}\n{path}\n'
   lfs: assuming remote store: http://localhost:$HGPORT/.git/info/lfs
   version https://git-lfs.github.com/spec/v1
   oid sha256:cf1b2787b74e66547d931b6ebe28ff63303e803cb2baa14a8f57c4383d875782
   size 20
   x-is-binary 0
   
   lfspair1.bin
 
   $ hg --cwd $TESTTMP/bulkfetch cat -vr tip lfspair1.bin -T json
   lfs: assuming remote store: http://localhost:$HGPORT/.git/info/lfs
   [lfs: assuming remote store: http://localhost:$HGPORT/.git/info/lfs
   lfs: downloading cf1b2787b74e66547d931b6ebe28ff63303e803cb2baa14a8f57c4383d875782 (20 bytes)
   lfs: processed: cf1b2787b74e66547d931b6ebe28ff63303e803cb2baa14a8f57c4383d875782
   lfs: downloaded 1 files (20 bytes)
   lfs: found cf1b2787b74e66547d931b6ebe28ff63303e803cb2baa14a8f57c4383d875782 in the local lfs store
   
    {
     "data": "this is an lfs file\n",
     "path": "lfspair1.bin",
     "rawdata": "version https://git-lfs.github.com/spec/v1\noid sha256:cf1b2787b74e66547d931b6ebe28ff63303e803cb2baa14a8f57c4383d875782\nsize 20\nx-is-binary 0\n"
    }
   ]
 
   $ rm -r $TESTTMP/bulkfetch/.hg/store/lfs
 
   $ hg --cwd $TESTTMP/bulkfetch cat -vr tip lfspair1.bin -T '{data}\n'
   lfs: assuming remote store: http://localhost:$HGPORT/.git/info/lfs
   lfs: assuming remote store: http://localhost:$HGPORT/.git/info/lfs
   lfs: downloading cf1b2787b74e66547d931b6ebe28ff63303e803cb2baa14a8f57c4383d875782 (20 bytes)
   lfs: processed: cf1b2787b74e66547d931b6ebe28ff63303e803cb2baa14a8f57c4383d875782
   lfs: downloaded 1 files (20 bytes)
   lfs: found cf1b2787b74e66547d931b6ebe28ff63303e803cb2baa14a8f57c4383d875782 in the local lfs store
   this is an lfs file
   
   $ hg --cwd $TESTTMP/bulkfetch cat -vr tip lfspair2.bin
   lfs: assuming remote store: http://localhost:$HGPORT/.git/info/lfs
   lfs: assuming remote store: http://localhost:$HGPORT/.git/info/lfs
   lfs: downloading d96eda2c74b56e95cfb5ffb66b6503e198cc6fc4a09dc877de925feebc65786e (24 bytes)
   lfs: processed: d96eda2c74b56e95cfb5ffb66b6503e198cc6fc4a09dc877de925feebc65786e
   lfs: downloaded 1 files (24 bytes)
   lfs: found d96eda2c74b56e95cfb5ffb66b6503e198cc6fc4a09dc877de925feebc65786e in the local lfs store
   this is an lfs file too
 
 Export will prefetch all needed files across all needed revisions
 
   $ rm -r $TESTTMP/bulkfetch/.hg/store/lfs
   $ hg -R $TESTTMP/bulkfetch -v export -r 0:tip -o all.export
   lfs: assuming remote store: http://localhost:$HGPORT/.git/info/lfs
   exporting patches:
   lfs: assuming remote store: http://localhost:$HGPORT/.git/info/lfs
   lfs: need to transfer 4 objects (92 bytes)
   lfs: downloading a82f1c5cea0d40e3bb3a849686bb4e6ae47ca27e614de55c1ed0325698ef68de (25 bytes)
   lfs: processed: a82f1c5cea0d40e3bb3a849686bb4e6ae47ca27e614de55c1ed0325698ef68de
   lfs: downloading bed80f00180ac404b843628ab56a1c1984d6145c391cd1628a7dd7d2598d71fc (23 bytes)
   lfs: processed: bed80f00180ac404b843628ab56a1c1984d6145c391cd1628a7dd7d2598d71fc
   lfs: downloading cf1b2787b74e66547d931b6ebe28ff63303e803cb2baa14a8f57c4383d875782 (20 bytes)
   lfs: processed: cf1b2787b74e66547d931b6ebe28ff63303e803cb2baa14a8f57c4383d875782
   lfs: downloading d96eda2c74b56e95cfb5ffb66b6503e198cc6fc4a09dc877de925feebc65786e (24 bytes)
   lfs: processed: d96eda2c74b56e95cfb5ffb66b6503e198cc6fc4a09dc877de925feebc65786e
   lfs: downloaded 4 files (92 bytes)
   all.export
   lfs: found bed80f00180ac404b843628ab56a1c1984d6145c391cd1628a7dd7d2598d71fc in the local lfs store
   lfs: found a82f1c5cea0d40e3bb3a849686bb4e6ae47ca27e614de55c1ed0325698ef68de in the local lfs store
   lfs: found cf1b2787b74e66547d931b6ebe28ff63303e803cb2baa14a8f57c4383d875782 in the local lfs store
   lfs: found d96eda2c74b56e95cfb5ffb66b6503e198cc6fc4a09dc877de925feebc65786e in the local lfs store
 
 Export with selected files is used with `extdiff --patch`
 
   $ rm -r $TESTTMP/bulkfetch/.hg/store/lfs
   $ hg --config extensions.extdiff= \
   >    -R $TESTTMP/bulkfetch -v extdiff -r 2:tip --patch $TESTTMP/bulkfetch/lfs.bin
   lfs: assuming remote store: http://localhost:$HGPORT/.git/info/lfs
   lfs: assuming remote store: http://localhost:$HGPORT/.git/info/lfs
   lfs: downloading bed80f00180ac404b843628ab56a1c1984d6145c391cd1628a7dd7d2598d71fc (23 bytes)
   lfs: processed: bed80f00180ac404b843628ab56a1c1984d6145c391cd1628a7dd7d2598d71fc
   lfs: downloaded 1 files (23 bytes)
   */hg-8374dc4052cb.patch (glob)
   lfs: found bed80f00180ac404b843628ab56a1c1984d6145c391cd1628a7dd7d2598d71fc in the local lfs store
   */hg-9640b57e77b1.patch (glob)
   --- */hg-8374dc4052cb.patch	* (glob)
   +++ */hg-9640b57e77b1.patch	* (glob)
   @@ -2,12 +2,7 @@
    # User test
    # Date 0 0
    #      Thu Jan 01 00:00:00 1970 +0000
   -# Node ID 8374dc4052cbd388e79d9dc4ddb29784097aa354
   -# Parent  1477875038c60152e391238920a16381c627b487
   -lfs
   +# Node ID 9640b57e77b14c3a0144fb4478b6cc13e13ea0d1
   +# Parent  d3b84d50eacbd56638e11abce6b8616aaba54420
   +add lfs pair
    
   -diff -r 1477875038c6 -r 8374dc4052cb lfs.bin
   ---- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   -+++ b/lfs.bin	Thu Jan 01 00:00:00 1970 +0000
   -@@ -0,0 +1,1 @@
   -+this is a big lfs file
   cleaning up temp directory
   [1]
 
 Diff will prefetch files
 
   $ rm -r $TESTTMP/bulkfetch/.hg/store/lfs
   $ hg -R $TESTTMP/bulkfetch -v diff -r 2:tip
   lfs: assuming remote store: http://localhost:$HGPORT/.git/info/lfs
   lfs: assuming remote store: http://localhost:$HGPORT/.git/info/lfs
   lfs: need to transfer 4 objects (92 bytes)
   lfs: downloading a82f1c5cea0d40e3bb3a849686bb4e6ae47ca27e614de55c1ed0325698ef68de (25 bytes)
   lfs: processed: a82f1c5cea0d40e3bb3a849686bb4e6ae47ca27e614de55c1ed0325698ef68de
   lfs: downloading bed80f00180ac404b843628ab56a1c1984d6145c391cd1628a7dd7d2598d71fc (23 bytes)
   lfs: processed: bed80f00180ac404b843628ab56a1c1984d6145c391cd1628a7dd7d2598d71fc
   lfs: downloading cf1b2787b74e66547d931b6ebe28ff63303e803cb2baa14a8f57c4383d875782 (20 bytes)
   lfs: processed: cf1b2787b74e66547d931b6ebe28ff63303e803cb2baa14a8f57c4383d875782
   lfs: downloading d96eda2c74b56e95cfb5ffb66b6503e198cc6fc4a09dc877de925feebc65786e (24 bytes)
   lfs: processed: d96eda2c74b56e95cfb5ffb66b6503e198cc6fc4a09dc877de925feebc65786e
   lfs: downloaded 4 files (92 bytes)
   lfs: found bed80f00180ac404b843628ab56a1c1984d6145c391cd1628a7dd7d2598d71fc in the local lfs store
   lfs: found a82f1c5cea0d40e3bb3a849686bb4e6ae47ca27e614de55c1ed0325698ef68de in the local lfs store
   lfs: found cf1b2787b74e66547d931b6ebe28ff63303e803cb2baa14a8f57c4383d875782 in the local lfs store
   lfs: found d96eda2c74b56e95cfb5ffb66b6503e198cc6fc4a09dc877de925feebc65786e in the local lfs store
   diff -r 8374dc4052cb -r 9640b57e77b1 lfs.bin
   --- a/lfs.bin	Thu Jan 01 00:00:00 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +0,0 @@
   -this is a big lfs file
   diff -r 8374dc4052cb -r 9640b57e77b1 lfs2.txt
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/lfs2.txt	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +this is another lfs file
   diff -r 8374dc4052cb -r 9640b57e77b1 lfspair1.bin
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/lfspair1.bin	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +this is an lfs file
   diff -r 8374dc4052cb -r 9640b57e77b1 lfspair2.bin
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/lfspair2.bin	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +this is an lfs file too
   diff -r 8374dc4052cb -r 9640b57e77b1 nonlfs.txt
   --- a/nonlfs.txt	Thu Jan 01 00:00:00 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +0,0 @@
   -non-lfs
   diff -r 8374dc4052cb -r 9640b57e77b1 nonlfs3.txt
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/nonlfs3.txt	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +non-lfs
 
 Only the files required by diff are prefetched
 
   $ rm -r $TESTTMP/bulkfetch/.hg/store/lfs
   $ hg -R $TESTTMP/bulkfetch -v diff -r 2:tip $TESTTMP/bulkfetch/lfspair2.bin
   lfs: assuming remote store: http://localhost:$HGPORT/.git/info/lfs
   lfs: assuming remote store: http://localhost:$HGPORT/.git/info/lfs
   lfs: downloading d96eda2c74b56e95cfb5ffb66b6503e198cc6fc4a09dc877de925feebc65786e (24 bytes)
   lfs: processed: d96eda2c74b56e95cfb5ffb66b6503e198cc6fc4a09dc877de925feebc65786e
   lfs: downloaded 1 files (24 bytes)
   lfs: found d96eda2c74b56e95cfb5ffb66b6503e198cc6fc4a09dc877de925feebc65786e in the local lfs store
   diff -r 8374dc4052cb -r 9640b57e77b1 lfspair2.bin
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/lfspair2.bin	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +this is an lfs file too
 
 #endif
 
   $ "$PYTHON" $TESTDIR/killdaemons.py $DAEMON_PIDS
 
   $ cat $TESTTMP/errors.log

tests/test-narrow-clone-stream.t

@@ -1,101 +1,101 b''
 #testcases tree flat-fncache flat-nofncache
 
 Tests narrow stream clones
 
   $ . "$TESTDIR/narrow-library.sh"
 
 #if tree
   $ cat << EOF >> $HGRCPATH
   > [experimental]
   > treemanifest = 1
   > EOF
 #endif
 
 #if flat-nofncache
   $ cat << EOF >> $HGRCPATH
   > [format]
   > usefncache = 0
   > EOF
 #endif
 
 Server setup
 
   $ hg init master
   $ cd master
   $ mkdir dir
   $ mkdir dir/src
   $ cd dir/src
   $ for x in `$TESTDIR/seq.py 20`; do echo $x > "F$x"; hg add "F$x"; hg commit -m "Commit src $x"; done
 
   $ cd ..
   $ mkdir tests
   $ cd tests
   $ for x in `$TESTDIR/seq.py 20`; do echo $x > "F$x"; hg add "F$x"; hg commit -m "Commit src $x"; done
   $ cd ../../..
 
 Trying to stream clone when the server does not support it
 
   $ hg clone --narrow ssh://user@dummy/master narrow --noupdate --include "dir/src/F10" --stream
   streaming all changes
   remote: abort: server does not support narrow stream clones
   abort: pull failed on remote
-  [255]
+  [100]
 
 Enable stream clone on the server
 
   $ echo "[experimental]" >> master/.hg/hgrc
   $ echo "server.stream-narrow-clones=True" >> master/.hg/hgrc
 
 Cloning a specific file when stream clone is supported
 
   $ hg clone --narrow ssh://user@dummy/master narrow --noupdate --include "dir/src/F10" --stream
   streaming all changes
   * files to transfer, * KB of data (glob)
   transferred * KB in * seconds (* */sec) (glob)
 
   $ cd narrow
   $ ls -A
   .hg
   $ hg tracked
   I path:dir/src/F10
 
 Making sure we have the correct set of requirements
 
   $ cat .hg/requires
   dotencode (tree !)
   dotencode (flat-fncache !)
   fncache (tree !)
   fncache (flat-fncache !)
   generaldelta
   narrowhg-experimental
   persistent-nodemap (rust !)
   revlog-compression-zstd (zstd !)
   revlogv1
   sparserevlog
   store
   treemanifest (tree !)
 
 Making sure store has the required files
 
   $ ls .hg/store/
   00changelog.i
   00manifest.i
   data
   fncache (tree !)
   fncache (flat-fncache !)
   meta (tree !)
   narrowspec
   undo
   undo.backupfiles
   undo.narrowspec
   undo.phaseroots
 
 Checking that repository has all the required data and not broken
 
   $ hg verify
   checking changesets
   checking manifests
   checking directory manifests (tree !)
   crosschecking files in changesets and manifests
   checking files
   checked 40 changesets with 1 changes to 1 files

tests/test-narrow-pull.t

@@ -1,154 +1,154 b''
   $ . "$TESTDIR/narrow-library.sh"
 
   $ hg init master
   $ cd master
   $ cat >> .hg/hgrc <<EOF
   > [narrow]
   > serveellipses=True
   > EOF
   $ for x in `$TESTDIR/seq.py 10`
   > do
   >   echo $x > "f$x"
   >   hg add "f$x"
   >   hg commit -m "Commit f$x"
   > done
   $ cd ..
 
 narrow clone a couple files, f2 and f8
 
   $ hg clone --narrow ssh://user@dummy/master narrow --include "f2" --include "f8"
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 5 changesets with 2 changes to 2 files
   new changesets *:* (glob)
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd narrow
   $ ls -A
   .hg
   f2
   f8
   $ cat f2 f8
   2
   8
 
   $ cd ..
 
 change every upstream file twice
 
   $ cd master
   $ for x in `$TESTDIR/seq.py 10`
   > do
   >   echo "update#1 $x" >> "f$x"
   >   hg commit -m "Update#1 to f$x" "f$x"
   > done
   $ for x in `$TESTDIR/seq.py 10`
   > do
   >   echo "update#2 $x" >> "f$x"
   >   hg commit -m "Update#2 to f$x" "f$x"
   > done
   $ cd ..
 
 look for incoming changes
 
   $ cd narrow
   $ hg incoming --limit 3
   comparing with ssh://user@dummy/master
   searching for changes
   changeset:   5:ddc055582556
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Update#1 to f1
   
   changeset:   6:f66eb5ad621d
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Update#1 to f2
   
   changeset:   7:c42ecff04e99
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Update#1 to f3
   
 
 Interrupting the pull is safe
   $ hg --config hooks.pretxnchangegroup.bad=false pull -q
   transaction abort!
   rollback completed
   abort: pretxnchangegroup.bad hook exited with status 1
   [40]
   $ hg id
   223311e70a6f tip
 
 pull new changes down to the narrow clone. Should get 8 new changesets: 4
 relevant to the narrow spec, and 4 ellipsis nodes gluing them all together.
 
   $ hg pull
   pulling from ssh://user@dummy/master
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 9 changesets with 4 changes to 2 files
   new changesets *:* (glob)
   (run 'hg update' to get a working copy)
   $ hg log -T '{rev}: {desc}\n'
   13: Update#2 to f10
   12: Update#2 to f8
   11: Update#2 to f7
   10: Update#2 to f2
   9: Update#2 to f1
   8: Update#1 to f8
   7: Update#1 to f7
   6: Update#1 to f2
   5: Update#1 to f1
   4: Commit f10
   3: Commit f8
   2: Commit f7
   1: Commit f2
   0: Commit f1
   $ hg update tip
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 add a change and push it
 
   $ echo "update#3 2" >> f2
   $ hg commit -m "Update#3 to f2" f2
   $ hg log f2 -T '{rev}: {desc}\n'
   14: Update#3 to f2
   10: Update#2 to f2
   6: Update#1 to f2
   1: Commit f2
   $ hg push
   pushing to ssh://user@dummy/master
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 1 changesets with 1 changes to 1 files
   $ cd ..
 
   $ cd master
   $ hg log f2 -T '{rev}: {desc}\n'
   30: Update#3 to f2
   21: Update#2 to f2
   11: Update#1 to f2
   1: Commit f2
   $ hg log -l 3 -T '{rev}: {desc}\n'
   30: Update#3 to f2
   29: Update#2 to f10
   28: Update#2 to f9
 
 Can pull into repo with a single commit
 
   $ cd ..
   $ hg clone -q --narrow ssh://user@dummy/master narrow2 --include "f1" -r 0
   $ cd narrow2
   $ hg pull -q -r 1
   remote: abort: unexpected error: unable to resolve parent while packing '00manifest.i' 1 for changeset 0
   transaction abort!
   rollback completed
   abort: pull failed on remote
-  [255]
+  [100]

tests/test-narrow-shallow.t

@@ -1,118 +1,118 b''
 #require no-reposimplestore
 
   $ . "$TESTDIR/narrow-library.sh"
 
   $ hg init master
   $ cd master
   $ cat >> .hg/hgrc <<EOF
   > [narrow]
   > serveellipses=True
   > EOF
   $ for x in `$TESTDIR/seq.py 10`
   > do
   >   echo $x > "f$x"
   >   hg add "f$x"
   > done
   $ hg commit -m "Add root files"
   $ mkdir d1 d2
   $ for x in `$TESTDIR/seq.py 10`
   > do
   >   echo d1/$x > "d1/f$x"
   >   hg add "d1/f$x"
   >   echo d2/$x > "d2/f$x"
   >   hg add "d2/f$x"
   > done
   $ hg commit -m "Add d1 and d2"
   $ for x in `$TESTDIR/seq.py 10`
   > do
   >   echo f$x rev2 > "f$x"
   >   echo d1/f$x rev2 > "d1/f$x"
   >   echo d2/f$x rev2 > "d2/f$x"
   >   hg commit -m "Commit rev2 of f$x, d1/f$x, d2/f$x"
   > done
   $ cd ..
 
 narrow and shallow clone the d2 directory
 
   $ hg clone --narrow ssh://user@dummy/master shallow --include "d2" --depth 2
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 13 changes to 10 files
   new changesets *:* (glob)
   updating to branch default
   10 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd shallow
   $ hg log -T '{rev}{if(ellipsis,"...")}: {desc}\n'
   3: Commit rev2 of f10, d1/f10, d2/f10
   2: Commit rev2 of f9, d1/f9, d2/f9
   1: Commit rev2 of f8, d1/f8, d2/f8
   0...: Commit rev2 of f7, d1/f7, d2/f7
   $ hg update 0
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat d2/f7 d2/f8
   d2/f7 rev2
   d2/8
 
   $ cd ..
 
 change every upstream file once
 
   $ cd master
   $ for x in `$TESTDIR/seq.py 10`
   > do
   >   echo f$x rev3 > "f$x"
   >   echo d1/f$x rev3 > "d1/f$x"
   >   echo d2/f$x rev3 > "d2/f$x"
   >   hg commit -m "Commit rev3 of f$x, d1/f$x, d2/f$x"
   > done
   $ cd ..
 
 pull new changes with --depth specified. There were 10 changes to the d2
 directory but the shallow pull should only fetch 3.
 
   $ cd shallow
   $ hg pull --depth 2
   pulling from ssh://user@dummy/master
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 10 changes to 10 files
   new changesets *:* (glob)
   (run 'hg update' to get a working copy)
   $ hg log -T '{rev}{if(ellipsis,"...")}: {desc}\n'
   7: Commit rev3 of f10, d1/f10, d2/f10
   6: Commit rev3 of f9, d1/f9, d2/f9
   5: Commit rev3 of f8, d1/f8, d2/f8
   4...: Commit rev3 of f7, d1/f7, d2/f7
   3: Commit rev2 of f10, d1/f10, d2/f10
   2: Commit rev2 of f9, d1/f9, d2/f9
   1: Commit rev2 of f8, d1/f8, d2/f8
   0...: Commit rev2 of f7, d1/f7, d2/f7
 
   $ hg update 4
   10 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat d2/f7 d2/f8
   d2/f7 rev3
   d2/f8 rev2
   $ hg update 7
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat d2/f10
   d2/f10 rev3
 
   $ cd ..
 
 cannot clone with zero or negative depth
 
   $ hg clone --narrow ssh://user@dummy/master bad --include "d2" --depth 0
   requesting all changes
   remote: abort: depth must be positive, got 0
   abort: pull failed on remote
-  [255]
+  [100]
   $ hg clone --narrow ssh://user@dummy/master bad --include "d2" --depth -1
   requesting all changes
   remote: abort: depth must be positive, got -1
   abort: pull failed on remote
-  [255]
+  [100]

tests/test-remotefilelog-clone-tree.t

@@ -1,124 +1,124 b''
 #require no-windows
 
   $ . "$TESTDIR/remotefilelog-library.sh"
 
   $ hg init master
   $ cd master
   $ echo treemanifest >> .hg/requires
   $ cat >> .hg/hgrc <<EOF
   > [remotefilelog]
   > server=True
   > EOF
 # uppercase directory name to test encoding
   $ mkdir -p A/B
   $ echo x > A/B/x
   $ hg commit -qAm x
 
   $ cd ..
 
 # shallow clone from full
 
   $ hgcloneshallow ssh://user@dummy/master shallow --noupdate
   streaming all changes
   4 files to transfer, 449 bytes of data
   transferred 449 bytes in * seconds (*/sec) (glob)
   searching for changes
   no changes found
   $ cd shallow
   $ cat .hg/requires
   dotencode
   exp-remotefilelog-repo-req-1
   fncache
   generaldelta
   persistent-nodemap (rust !)
   revlog-compression-zstd (zstd !)
   revlogv1
   sparserevlog
   store
   treemanifest
   $ find .hg/store/meta | sort
   .hg/store/meta
   .hg/store/meta/_a
   .hg/store/meta/_a/00manifest.i
   .hg/store/meta/_a/_b
   .hg/store/meta/_a/_b/00manifest.i
 
   $ hg update
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   1 files fetched over 1 fetches - (1 misses, 0.00% hit ratio) over *s (glob)
 
   $ cat A/B/x
   x
 
   $ ls .hg/store/data
   $ echo foo > A/B/F
   $ hg add A/B/F
   $ hg ci -m 'local content'
   $ ls .hg/store/data
   ca31988f085bfb945cb8115b78fabdee40f741aa
 
   $ cd ..
 
 # shallow clone from shallow
 
   $ hgcloneshallow ssh://user@dummy/shallow shallow2  --noupdate
   streaming all changes
   5 files to transfer, 1008 bytes of data
   transferred 1008 bytes in * seconds (*/sec) (glob)
   searching for changes
   no changes found
   $ cd shallow2
   $ cat .hg/requires
   dotencode
   exp-remotefilelog-repo-req-1
   fncache
   generaldelta
   persistent-nodemap (rust !)
   revlog-compression-zstd (zstd !)
   revlogv1
   sparserevlog
   store
   treemanifest
   $ ls .hg/store/data
   ca31988f085bfb945cb8115b78fabdee40f741aa
 
   $ hg update
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cat A/B/x
   x
 
   $ cd ..
 
 # full clone from shallow
 # - send stderr to /dev/null because the order of stdout/err causes
 #   flakiness here
   $ hg clone --noupdate ssh://user@dummy/shallow full 2>/dev/null
   streaming all changes
-  [255]
+  [100]
 
 # getbundle full clone
 
   $ printf '[server]\npreferuncompressed=False\n' >> master/.hg/hgrc
   $ hgcloneshallow ssh://user@dummy/master shallow3
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 0 changes to 0 files
   new changesets 18d955ee7ba0
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ ls shallow3/.hg/store/data
   $ cat shallow3/.hg/requires
   dotencode
   exp-remotefilelog-repo-req-1
   fncache
   generaldelta
   persistent-nodemap (rust !)
   revlog-compression-zstd (zstd !)
   revlogv1
   sparserevlog
   store
   treemanifest

tests/test-remotefilelog-clone.t

@@ -1,121 +1,121 b''
 #require no-windows
 
   $ . "$TESTDIR/remotefilelog-library.sh"
 
   $ hg init master
   $ cd master
   $ cat >> .hg/hgrc <<EOF
   > [remotefilelog]
   > server=True
   > EOF
   $ echo x > x
   $ hg commit -qAm x
 
   $ cd ..
 
 # shallow clone from full
 
   $ hgcloneshallow ssh://user@dummy/master shallow --noupdate
   streaming all changes
   2 files to transfer, 227 bytes of data
   transferred 227 bytes in * seconds (*/sec) (glob)
   searching for changes
   no changes found
   $ cd shallow
   $ cat .hg/requires
   dotencode
   exp-remotefilelog-repo-req-1
   fncache
   generaldelta
   persistent-nodemap (rust !)
   revlog-compression-zstd (zstd !)
   revlogv1
   sparserevlog
   store
 
   $ hg update
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   1 files fetched over 1 fetches - (1 misses, 0.00% hit ratio) over *s (glob)
 
   $ cat x
   x
 
   $ ls .hg/store/data
   $ echo foo > f
   $ hg add f
   $ hg ci -m 'local content'
   $ ls .hg/store/data
   4a0a19218e082a343a1b17e5333409af9d98f0f5
 
   $ cd ..
 
 # shallow clone from shallow
 
   $ hgcloneshallow ssh://user@dummy/shallow shallow2  --noupdate
   streaming all changes
   3 files to transfer, 564 bytes of data
   transferred 564 bytes in * seconds (*/sec) (glob)
   searching for changes
   no changes found
   $ cd shallow2
   $ cat .hg/requires
   dotencode
   exp-remotefilelog-repo-req-1
   fncache
   generaldelta
   persistent-nodemap (rust !)
   revlog-compression-zstd (zstd !)
   revlogv1
   sparserevlog
   store
   $ ls .hg/store/data
   4a0a19218e082a343a1b17e5333409af9d98f0f5
 
   $ hg update
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cat x
   x
 
   $ cd ..
 
 # full clone from shallow
 
 Note: the output to STDERR comes from a different process to the output on
 STDOUT and their relative ordering is not deterministic. As a result, the test
 was failing sporadically. To avoid this, we capture STDERR to a file and
 check its contents separately.
 
   $ TEMP_STDERR=full-clone-from-shallow.stderr.tmp
   $ hg clone --noupdate ssh://user@dummy/shallow full 2>$TEMP_STDERR
   streaming all changes
-  [255]
+  [100]
   $ cat $TEMP_STDERR
   remote: abort: Cannot clone from a shallow repo to a full repo.
   abort: pull failed on remote
   $ rm $TEMP_STDERR
 
 # getbundle full clone
 
   $ printf '[server]\npreferuncompressed=False\n' >> master/.hg/hgrc
   $ hgcloneshallow ssh://user@dummy/master shallow3
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 0 changes to 0 files
   new changesets b292c1e3311f
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ ls shallow3/.hg/store/data
   $ cat shallow3/.hg/requires
   dotencode
   exp-remotefilelog-repo-req-1
   fncache
   generaldelta
   persistent-nodemap (rust !)
   revlog-compression-zstd (zstd !)
   revlogv1
   sparserevlog
   store

tests/test-ssh.t

@@ -1,733 +1,733 b''
 #testcases sshv1 sshv2
 
 #if sshv2
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > sshpeer.advertise-v2 = true
   > sshserver.support-v2 = true
   > EOF
 #endif
 
 This test tries to exercise the ssh functionality with a dummy script
 
 creating 'remote' repo
 
   $ hg init remote
   $ cd remote
   $ echo this > foo
   $ echo this > fooO
   $ hg ci -A -m "init" foo fooO
 
 insert a closed branch (issue4428)
 
   $ hg up null
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg branch closed
   marked working directory as branch closed
   (branches are permanent and global, did you want a bookmark?)
   $ hg ci -mc0
   $ hg ci --close-branch -mc1
   $ hg up -q default
 
 configure for serving
 
   $ cat <<EOF > .hg/hgrc
   > [server]
   > uncompressed = True
   > 
   > [hooks]
   > changegroup = sh -c "printenv.py --line changegroup-in-remote 0 ../dummylog"
   > EOF
   $ cd $TESTTMP
 
 repo not found error
 
   $ hg clone -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" ssh://user@dummy/nonexistent local
   remote: abort: repository nonexistent not found
   abort: no suitable response from remote hg
   [255]
   $ hg clone -q -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" ssh://user@dummy/nonexistent local
   remote: abort: repository nonexistent not found
   abort: no suitable response from remote hg
   [255]
 
 non-existent absolute path
 
   $ hg clone -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" ssh://user@dummy/`pwd`/nonexistent local
   remote: abort: repository $TESTTMP/nonexistent not found
   abort: no suitable response from remote hg
   [255]
 
 clone remote via stream
 
 #if no-reposimplestore
 
   $ hg clone -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" --stream ssh://user@dummy/remote local-stream
   streaming all changes
   8 files to transfer, 827 bytes of data (no-zstd !)
   transferred 827 bytes in * seconds (*) (glob) (no-zstd !)
   8 files to transfer, 846 bytes of data (zstd !)
   transferred * bytes in * seconds (* */sec) (glob) (zstd !)
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd local-stream
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 3 changesets with 2 changes to 2 files
   $ hg branches
   default                        0:1160648e36ce
   $ cd $TESTTMP
 
 clone bookmarks via stream
 
   $ hg -R local-stream book mybook
   $ hg clone -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" --stream ssh://user@dummy/local-stream stream2
   streaming all changes
   16 files to transfer, * of data (glob)
   transferred * in * seconds (*) (glob)
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd stream2
   $ hg book
      mybook                    0:1160648e36ce
   $ cd $TESTTMP
   $ rm -rf local-stream stream2
 
 #endif
 
 clone remote via pull
 
   $ hg clone -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" ssh://user@dummy/remote local
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 2 changes to 2 files
   new changesets 1160648e36ce:ad076bfb429d
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 verify
 
   $ cd local
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 3 changesets with 2 changes to 2 files
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > changegroup = sh -c "printenv.py changegroup-in-local 0 ../dummylog"
   > EOF
 
 empty default pull
 
   $ hg paths
   default = ssh://user@dummy/remote
   $ hg pull -e "\"$PYTHON\" \"$TESTDIR/dummyssh\""
   pulling from ssh://user@dummy/remote
   searching for changes
   no changes found
 
 pull from wrong ssh URL
 
   $ hg pull -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" ssh://user@dummy/doesnotexist
   pulling from ssh://user@dummy/doesnotexist
   remote: abort: repository doesnotexist not found
   abort: no suitable response from remote hg
   [255]
 
 local change
 
   $ echo bleah > foo
   $ hg ci -m "add"
 
 updating rc
 
   $ echo "default-push = ssh://user@dummy/remote" >> .hg/hgrc
   $ echo "[ui]" >> .hg/hgrc
   $ echo "ssh = \"$PYTHON\" \"$TESTDIR/dummyssh\"" >> .hg/hgrc
 
 find outgoing
 
   $ hg out ssh://user@dummy/remote
   comparing with ssh://user@dummy/remote
   searching for changes
   changeset:   3:a28a9d1a809c
   tag:         tip
   parent:      0:1160648e36ce
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add
   
 
 find incoming on the remote side
 
   $ hg incoming -R ../remote -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" ssh://user@dummy/local
   comparing with ssh://user@dummy/local
   searching for changes
   changeset:   3:a28a9d1a809c
   tag:         tip
   parent:      0:1160648e36ce
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add
   
 
 find incoming on the remote side (using absolute path)
 
   $ hg incoming -R ../remote -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" "ssh://user@dummy/`pwd`"
   comparing with ssh://user@dummy/$TESTTMP/local
   searching for changes
   changeset:   3:a28a9d1a809c
   tag:         tip
   parent:      0:1160648e36ce
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add
   
 
 push
 
   $ hg push
   pushing to ssh://user@dummy/remote
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 1 changesets with 1 changes to 1 files
   $ cd $TESTTMP/remote
 
 check remote tip
 
   $ hg tip
   changeset:   3:a28a9d1a809c
   tag:         tip
   parent:      0:1160648e36ce
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add
   
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 4 changesets with 3 changes to 2 files
   $ hg cat -r tip foo
   bleah
   $ echo z > z
   $ hg ci -A -m z z
   created new head
 
 test pushkeys and bookmarks
 
   $ cd $TESTTMP/local
   $ hg debugpushkey --config ui.ssh="\"$PYTHON\" \"$TESTDIR/dummyssh\"" ssh://user@dummy/remote namespaces
   bookmarks	
   namespaces	
   phases	
   $ hg book foo -r 0
   $ hg out -B --config paths.default=bogus://invalid --config paths.default:pushurl=`hg paths default`
   comparing with ssh://user@dummy/remote
   searching for changed bookmarks
      foo                       1160648e36ce
   $ hg push -B foo
   pushing to ssh://user@dummy/remote
   searching for changes
   no changes found
   exporting bookmark foo
   [1]
   $ hg debugpushkey --config ui.ssh="\"$PYTHON\" \"$TESTDIR/dummyssh\"" ssh://user@dummy/remote bookmarks
   foo	1160648e36cec0054048a7edc4110c6f84fde594
   $ hg book -f foo
   $ hg push --traceback
   pushing to ssh://user@dummy/remote
   searching for changes
   no changes found
   updating bookmark foo
   [1]
   $ hg book -d foo
   $ hg in -B
   comparing with ssh://user@dummy/remote
   searching for changed bookmarks
      foo                       a28a9d1a809c
   $ hg book -f -r 0 foo
   $ hg pull -B foo
   pulling from ssh://user@dummy/remote
   no changes found
   updating bookmark foo
   $ hg book -d foo
   $ hg push -B foo
   pushing to ssh://user@dummy/remote
   searching for changes
   no changes found
   deleting remote bookmark foo
   [1]
 
 a bad, evil hook that prints to stdout
 
   $ cat <<EOF > $TESTTMP/badhook
   > import sys
   > sys.stdout.write("KABOOM\n")
   > sys.stdout.flush()
   > EOF
 
   $ cat <<EOF > $TESTTMP/badpyhook.py
   > import sys
   > def hook(ui, repo, hooktype, **kwargs):
   >     sys.stdout.write("KABOOM IN PROCESS\n")
   >     sys.stdout.flush()
   > EOF
 
   $ cat <<EOF >> ../remote/.hg/hgrc
   > [hooks]
   > changegroup.stdout = "$PYTHON" $TESTTMP/badhook
   > changegroup.pystdout = python:$TESTTMP/badpyhook.py:hook
   > EOF
   $ echo r > r
   $ hg ci -A -m z r
 
 push should succeed even though it has an unexpected response
 
   $ hg push
   pushing to ssh://user@dummy/remote
   searching for changes
   remote has heads on branch 'default' that are not known locally: 6c0482d977a3
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 1 changesets with 1 changes to 1 files
   remote: KABOOM
   remote: KABOOM IN PROCESS
   $ hg -R ../remote heads
   changeset:   5:1383141674ec
   tag:         tip
   parent:      3:a28a9d1a809c
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     z
   
   changeset:   4:6c0482d977a3
   parent:      0:1160648e36ce
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     z
   
 
 #if chg
 
 try again with remote chg, which should succeed as well
 
   $ hg rollback -R ../remote
   repository tip rolled back to revision 4 (undo serve)
 
   $ hg push --config ui.remotecmd=chg
   pushing to ssh://user@dummy/remote
   searching for changes
   remote has heads on branch 'default' that are not known locally: 6c0482d977a3
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 1 changesets with 1 changes to 1 files (py3 !)
   remote: KABOOM
   remote: KABOOM IN PROCESS
   remote: added 1 changesets with 1 changes to 1 files (no-py3 !)
 
 #endif
 
 clone bookmarks
 
   $ hg -R ../remote bookmark test
   $ hg -R ../remote bookmarks
    * test                      4:6c0482d977a3
   $ hg clone -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" ssh://user@dummy/remote local-bookmarks
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 6 changesets with 5 changes to 4 files (+1 heads)
   new changesets 1160648e36ce:1383141674ec
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R local-bookmarks bookmarks
      test                      4:6c0482d977a3
 
 passwords in ssh urls are not supported
 (we use a glob here because different Python versions give different
 results here)
 
   $ hg push ssh://user:erroneouspwd@dummy/remote
   pushing to ssh://user:*@dummy/remote (glob)
   abort: password in URL not supported
   [255]
 
   $ cd $TESTTMP
 
 hide outer repo
   $ hg init
 
 Test remote paths with spaces (issue2983):
 
   $ hg init --ssh "\"$PYTHON\" \"$TESTDIR/dummyssh\"" "ssh://user@dummy/a repo"
   $ touch "$TESTTMP/a repo/test"
   $ hg -R 'a repo' commit -A -m "test"
   adding test
   $ hg -R 'a repo' tag tag
   $ hg id --ssh "\"$PYTHON\" \"$TESTDIR/dummyssh\"" "ssh://user@dummy/a repo"
   73649e48688a
 
   $ hg id --ssh "\"$PYTHON\" \"$TESTDIR/dummyssh\"" "ssh://user@dummy/a repo#noNoNO"
   abort: unknown revision 'noNoNO'
   [255]
 
 Test (non-)escaping of remote paths with spaces when cloning (issue3145):
 
   $ hg clone --ssh "\"$PYTHON\" \"$TESTDIR/dummyssh\"" "ssh://user@dummy/a repo"
   destination directory: a repo
   abort: destination 'a repo' is not empty
   [10]
 
 #if no-rhg
 Make sure hg is really paranoid in serve --stdio mode. It used to be
 possible to get a debugger REPL by specifying a repo named --debugger.
   $ hg -R --debugger serve --stdio
   abort: potentially unsafe serve --stdio invocation: ['-R', '--debugger', 'serve', '--stdio']
   [255]
   $ hg -R --config=ui.debugger=yes serve --stdio
   abort: potentially unsafe serve --stdio invocation: ['-R', '--config=ui.debugger=yes', 'serve', '--stdio']
   [255]
 Abbreviations of 'serve' also don't work, to avoid shenanigans.
   $ hg -R narf serv --stdio
   abort: potentially unsafe serve --stdio invocation: ['-R', 'narf', 'serv', '--stdio']
   [255]
 #else
 rhg aborts early on -R without a repository at that path
   $ hg -R --debugger serve --stdio
   abort: potentially unsafe serve --stdio invocation: ['-R', '--debugger', 'serve', '--stdio'] (missing-correct-output !)
   abort: repository --debugger not found (known-bad-output !)
   [255]
   $ hg -R --config=ui.debugger=yes serve --stdio
   abort: potentially unsafe serve --stdio invocation: ['-R', '--config=ui.debugger=yes', 'serve', '--stdio'] (missing-correct-output !)
   abort: repository --config=ui.debugger=yes not found (known-bad-output !)
   [255]
   $ hg -R narf serv --stdio
   abort: potentially unsafe serve --stdio invocation: ['-R', 'narf', 'serv', '--stdio'] (missing-correct-output !)
   abort: repository narf not found (known-bad-output !)
   [255]
 If the repo does exist, rhg finds an unsupported command and falls back to Python
 which still does the right thing
   $ hg init narf
   $ hg -R narf serv --stdio
   abort: potentially unsafe serve --stdio invocation: ['-R', 'narf', 'serv', '--stdio']
   [255]
 #endif
 
 Test hg-ssh using a helper script that will restore PYTHONPATH (which might
 have been cleared by a hg.exe wrapper) and invoke hg-ssh with the right
 parameters:
 
   $ cat > ssh.sh << EOF
   > userhost="\$1"
   > SSH_ORIGINAL_COMMAND="\$2"
   > export SSH_ORIGINAL_COMMAND
   > PYTHONPATH="$PYTHONPATH"
   > export PYTHONPATH
   > "$PYTHON" "$TESTDIR/../contrib/hg-ssh" "$TESTTMP/a repo"
   > EOF
 
   $ hg id --ssh "sh ssh.sh" "ssh://user@dummy/a repo"
   73649e48688a
 
   $ hg id --ssh "sh ssh.sh" "ssh://user@dummy/a'repo"
   remote: Illegal repository "$TESTTMP/a'repo"
   abort: no suitable response from remote hg
   [255]
 
   $ hg id --ssh "sh ssh.sh" --remotecmd hacking "ssh://user@dummy/a'repo"
   remote: Illegal command "hacking -R 'a'\''repo' serve --stdio"
   abort: no suitable response from remote hg
   [255]
 
   $ SSH_ORIGINAL_COMMAND="'hg' -R 'a'repo' serve --stdio" "$PYTHON" "$TESTDIR/../contrib/hg-ssh"
   Illegal command "'hg' -R 'a'repo' serve --stdio": No closing quotation
   [255]
 
 Test hg-ssh in read-only mode:
 
   $ cat > ssh.sh << EOF
   > userhost="\$1"
   > SSH_ORIGINAL_COMMAND="\$2"
   > export SSH_ORIGINAL_COMMAND
   > PYTHONPATH="$PYTHONPATH"
   > export PYTHONPATH
   > "$PYTHON" "$TESTDIR/../contrib/hg-ssh" --read-only "$TESTTMP/remote"
   > EOF
 
   $ hg clone --ssh "sh ssh.sh" "ssh://user@dummy/$TESTTMP/remote" read-only-local
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 6 changesets with 5 changes to 4 files (+1 heads)
   new changesets 1160648e36ce:1383141674ec
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cd read-only-local
   $ echo "baz" > bar
   $ hg ci -A -m "unpushable commit" bar
   $ hg push --ssh "sh ../ssh.sh"
   pushing to ssh://user@dummy/*/remote (glob)
   searching for changes
   remote: Permission denied
   remote: pretxnopen.hg-ssh hook failed
   abort: push failed on remote
-  [255]
+  [100]
 
   $ cd $TESTTMP
 
 stderr from remote commands should be printed before stdout from local code (issue4336)
 
   $ hg clone remote stderr-ordering
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd stderr-ordering
   $ cat >> localwrite.py << EOF
   > from mercurial import exchange, extensions
   > 
   > def wrappedpush(orig, repo, *args, **kwargs):
   >     res = orig(repo, *args, **kwargs)
   >     repo.ui.write(b'local stdout\n')
   >     repo.ui.flush()
   >     return res
   > 
   > def extsetup(ui):
   >     extensions.wrapfunction(exchange, b'push', wrappedpush)
   > EOF
 
   $ cat >> .hg/hgrc << EOF
   > [paths]
   > default-push = ssh://user@dummy/remote
   > [ui]
   > ssh = "$PYTHON" "$TESTDIR/dummyssh"
   > [extensions]
   > localwrite = localwrite.py
   > EOF
 
   $ echo localwrite > foo
   $ hg commit -m 'testing localwrite'
   $ hg push
   pushing to ssh://user@dummy/remote
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 1 changesets with 1 changes to 1 files
   remote: KABOOM
   remote: KABOOM IN PROCESS
   local stdout
 
 debug output
 
   $ hg pull --debug ssh://user@dummy/remote --config devel.debug.peer-request=yes
   pulling from ssh://user@dummy/remote
   running .* ".*/dummyssh" ['"]user@dummy['"] ('|")hg -R remote serve --stdio('|") (re)
   sending upgrade request: * proto=exp-ssh-v2-0003 (glob) (sshv2 !)
   devel-peer-request: hello+between
   devel-peer-request:   pairs: 81 bytes
   sending hello command
   sending between command
   remote: 444 (sshv1 no-rust !)
   remote: 463 (sshv1 rust !)
   protocol upgraded to exp-ssh-v2-0003 (sshv2 !)
   remote: capabilities: batch branchmap $USUAL_BUNDLE2_CAPS$ changegroupsubset getbundle known lookup protocaps pushkey streamreqs=generaldelta,revlogv1,sparserevlog unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash (no-rust !)
   remote: capabilities: batch branchmap $USUAL_BUNDLE2_CAPS$ changegroupsubset getbundle known lookup protocaps pushkey streamreqs=generaldelta,persistent-nodemap,revlogv1,sparserevlog unbundle=HG10GZ,HG10BZ,HG10UN unbundlehash (rust !)
   remote: 1 (sshv1 !)
   devel-peer-request: protocaps
   devel-peer-request:   caps: * bytes (glob)
   sending protocaps command
   query 1; heads
   devel-peer-request: batched-content
   devel-peer-request:    - heads (0 arguments)
   devel-peer-request:    - known (1 arguments)
   devel-peer-request: batch
   devel-peer-request:   cmds: 141 bytes
   sending batch command
   searching for changes
   all remote heads known locally
   no changes found
   devel-peer-request: getbundle
   devel-peer-request:   bookmarks: 1 bytes
   devel-peer-request:   bundlecaps: 270 bytes
   devel-peer-request:   cg: 1 bytes
   devel-peer-request:   common: 122 bytes
   devel-peer-request:   heads: 122 bytes
   devel-peer-request:   listkeys: 9 bytes
   devel-peer-request:   phases: 1 bytes
   sending getbundle command
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "bookmarks" supported
   bundle2-input-part: total payload size 26
   bundle2-input-part: "listkeys" (params: 1 mandatory) supported
   bundle2-input-part: total payload size 45
   bundle2-input-part: "phase-heads" supported
   bundle2-input-part: total payload size 72
   bundle2-input-bundle: 3 parts total
   checking for updated bookmarks
 
   $ cd $TESTTMP
 
   $ cat dummylog
   Got arguments 1:user@dummy 2:hg -R nonexistent serve --stdio
   Got arguments 1:user@dummy 2:hg -R nonexistent serve --stdio
   Got arguments 1:user@dummy 2:hg -R $TESTTMP/nonexistent serve --stdio
   Got arguments 1:user@dummy 2:hg -R remote serve --stdio
   Got arguments 1:user@dummy 2:hg -R local-stream serve --stdio (no-reposimplestore !)
   Got arguments 1:user@dummy 2:hg -R remote serve --stdio (no-reposimplestore !)
   Got arguments 1:user@dummy 2:hg -R remote serve --stdio (no-reposimplestore !)
   Got arguments 1:user@dummy 2:hg -R doesnotexist serve --stdio
   Got arguments 1:user@dummy 2:hg -R remote serve --stdio
   Got arguments 1:user@dummy 2:hg -R local serve --stdio
   Got arguments 1:user@dummy 2:hg -R $TESTTMP/local serve --stdio
   Got arguments 1:user@dummy 2:hg -R remote serve --stdio
   changegroup-in-remote hook: HG_BUNDLE2=1
   HG_HOOKNAME=changegroup
   HG_HOOKTYPE=changegroup
   HG_NODE=a28a9d1a809cab7d4e2fde4bee738a9ede948b60
   HG_NODE_LAST=a28a9d1a809cab7d4e2fde4bee738a9ede948b60
   HG_SOURCE=serve
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=serve
   HG_URL=remote:ssh:$LOCALIP
   
   Got arguments 1:user@dummy 2:hg -R remote serve --stdio
   Got arguments 1:user@dummy 2:hg -R remote serve --stdio
   Got arguments 1:user@dummy 2:hg -R remote serve --stdio
   Got arguments 1:user@dummy 2:hg -R remote serve --stdio
   Got arguments 1:user@dummy 2:hg -R remote serve --stdio
   Got arguments 1:user@dummy 2:hg -R remote serve --stdio
   Got arguments 1:user@dummy 2:hg -R remote serve --stdio
   Got arguments 1:user@dummy 2:hg -R remote serve --stdio
   Got arguments 1:user@dummy 2:hg -R remote serve --stdio
   changegroup-in-remote hook: HG_BUNDLE2=1
   HG_HOOKNAME=changegroup
   HG_HOOKTYPE=changegroup
   HG_NODE=1383141674ec756a6056f6a9097618482fe0f4a6
   HG_NODE_LAST=1383141674ec756a6056f6a9097618482fe0f4a6
   HG_SOURCE=serve
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=serve
   HG_URL=remote:ssh:$LOCALIP
   
   Got arguments 1:user@dummy 2:chg -R remote serve --stdio (chg !)
   changegroup-in-remote hook: HG_BUNDLE2=1 (chg !)
   HG_HOOKNAME=changegroup (chg !)
   HG_HOOKTYPE=changegroup (chg !)
   HG_NODE=1383141674ec756a6056f6a9097618482fe0f4a6 (chg !)
   HG_NODE_LAST=1383141674ec756a6056f6a9097618482fe0f4a6 (chg !)
   HG_SOURCE=serve (chg !)
   HG_TXNID=TXN:$ID$ (chg !)
   HG_TXNNAME=serve (chg !)
   HG_URL=remote:ssh:$LOCALIP (chg !)
    (chg !)
   Got arguments 1:user@dummy 2:hg -R remote serve --stdio
   Got arguments 1:user@dummy 2:hg init 'a repo'
   Got arguments 1:user@dummy 2:hg -R 'a repo' serve --stdio
   Got arguments 1:user@dummy 2:hg -R 'a repo' serve --stdio
   Got arguments 1:user@dummy 2:hg -R 'a repo' serve --stdio
   Got arguments 1:user@dummy 2:hg -R 'a repo' serve --stdio
   Got arguments 1:user@dummy 2:hg -R remote serve --stdio
   changegroup-in-remote hook: HG_BUNDLE2=1
   HG_HOOKNAME=changegroup
   HG_HOOKTYPE=changegroup
   HG_NODE=65c38f4125f9602c8db4af56530cc221d93b8ef8
   HG_NODE_LAST=65c38f4125f9602c8db4af56530cc221d93b8ef8
   HG_SOURCE=serve
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=serve
   HG_URL=remote:ssh:$LOCALIP
   
   Got arguments 1:user@dummy 2:hg -R remote serve --stdio
 
 
 remote hook failure is attributed to remote
 
   $ cat > $TESTTMP/failhook << EOF
   > def hook(ui, repo, **kwargs):
   >     ui.write(b'hook failure!\n')
   >     ui.flush()
   >     return 1
   > EOF
 
   $ echo "pretxnchangegroup.fail = python:$TESTTMP/failhook:hook" >> remote/.hg/hgrc
 
   $ hg -q --config ui.ssh="\"$PYTHON\" $TESTDIR/dummyssh" clone ssh://user@dummy/remote hookout
   $ cd hookout
   $ touch hookfailure
   $ hg -q commit -A -m 'remote hook failure'
   $ hg --config ui.ssh="\"$PYTHON\" $TESTDIR/dummyssh" push
   pushing to ssh://user@dummy/remote
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: hook failure!
   remote: transaction abort!
   remote: rollback completed
   remote: pretxnchangegroup.fail hook failed
   abort: push failed on remote
-  [255]
+  [100]
 
 abort during pull is properly reported as such
 
   $ echo morefoo >> ../remote/foo
   $ hg -R ../remote commit --message "more foo to be pulled"
   $ cat >> ../remote/.hg/hgrc << EOF
   > [extensions]
   > crash = ${TESTDIR}/crashgetbundler.py
   > EOF
   $ hg --config ui.ssh="\"$PYTHON\" $TESTDIR/dummyssh" pull
   pulling from ssh://user@dummy/remote
   searching for changes
   remote: abort: this is an exercise
   abort: pull failed on remote
-  [255]
+  [100]
 
 abort with no error hint when there is a ssh problem when pulling
 
   $ hg pull ssh://brokenrepository -e "\"$PYTHON\" \"$TESTDIR/dummyssh\""
   pulling from ssh://brokenrepository/
   abort: no suitable response from remote hg
   [255]
 
 abort with configured error hint when there is a ssh problem when pulling
 
   $ hg pull ssh://brokenrepository -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" \
   > --config ui.ssherrorhint="Please see http://company/internalwiki/ssh.html"
   pulling from ssh://brokenrepository/
   abort: no suitable response from remote hg
   (Please see http://company/internalwiki/ssh.html)
   [255]
 
 test that custom environment is passed down to ssh executable
   $ cat >>dumpenv <<EOF
   > #! /bin/sh
   > echo \$VAR >&2
   > EOF
   $ chmod +x dumpenv
   $ hg pull ssh://something --config ui.ssh="sh dumpenv"
   pulling from ssh://something/
   remote: 
   abort: no suitable response from remote hg
   [255]
   $ hg pull ssh://something --config ui.ssh="sh dumpenv" --config sshenv.VAR=17
   pulling from ssh://something/
   remote: 17
   abort: no suitable response from remote hg
   [255]