changegroup: move message about added changes to transaction summary

Before that, applying multiple changegroups in the same transaction issued the
message multiple time. This result in a confusing output:

    adding changesets
    adding manifests
    adding file changes
    added 32768 changesets with 60829 changes to 2668 files
    adding changesets
    adding manifests
    adding file changes
    added 8192 changesets with 16885 changes to 1553 files
    adding changesets
    adding manifests
    adding file changes
    added 1020 changesets with 1799 changes to 536 files
    adding changesets
    adding manifests
    ...

Instead, we now only issue the message once at the end of the transaction,
summing up all added changesets, changes and files. The line is identical, but
happens sightly later in the output.

There are other suboptimal behavior around issue multiple changegroup (eg:
progress bar). We'll cover them later.

This impact of lot of test as one would expect, but a two pass check show they
are just the order change we expected.

To deal with "under the hood" bundle application by internal code, we had to
take a slightly hacky move. We could clean that up with a more official way to
enter "under the hood" section, however I want to keep this series simple to get
it landed. This kind of change have a very high bit rot rate since it impact a
lot of test output.

mercurial/changegroup.py

@@ -1,1426 +1,1441 b''
 # changegroup.py - Mercurial changegroup manipulation functions
 #
 #  Copyright 2006 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import os
 import struct
 import weakref
 
 from .i18n import _
 from .node import (
     hex,
     nullid,
     nullrev,
     short,
 )
 
 from . import (
     error,
     match as matchmod,
     mdiff,
     phases,
     pycompat,
     util,
 )
 
 from .interfaces import (
     repository,
 )
 
 _CHANGEGROUPV1_DELTA_HEADER = struct.Struct("20s20s20s20s")
 _CHANGEGROUPV2_DELTA_HEADER = struct.Struct("20s20s20s20s20s")
 _CHANGEGROUPV3_DELTA_HEADER = struct.Struct(">20s20s20s20s20sH")
 
 LFS_REQUIREMENT = 'lfs'
 
 readexactly = util.readexactly
 
 def getchunk(stream):
     """return the next chunk from stream as a string"""
     d = readexactly(stream, 4)
     l = struct.unpack(">l", d)[0]
     if l <= 4:
         if l:
             raise error.Abort(_("invalid chunk length %d") % l)
         return ""
     return readexactly(stream, l - 4)
 
 def chunkheader(length):
     """return a changegroup chunk header (string)"""
     return struct.pack(">l", length + 4)
 
 def closechunk():
     """return a changegroup chunk header (string) for a zero-length chunk"""
     return struct.pack(">l", 0)
 
 def _fileheader(path):
     """Obtain a changegroup chunk header for a named path."""
     return chunkheader(len(path)) + path
 
 def writechunks(ui, chunks, filename, vfs=None):
     """Write chunks to a file and return its filename.
 
     The stream is assumed to be a bundle file.
     Existing files will not be overwritten.
     If no filename is specified, a temporary file is created.
     """
     fh = None
     cleanup = None
     try:
         if filename:
             if vfs:
                 fh = vfs.open(filename, "wb")
             else:
                 # Increase default buffer size because default is usually
                 # small (4k is common on Linux).
                 fh = open(filename, "wb", 131072)
         else:
             fd, filename = pycompat.mkstemp(prefix="hg-bundle-", suffix=".hg")
             fh = os.fdopen(fd, r"wb")
         cleanup = filename
         for c in chunks:
             fh.write(c)
         cleanup = None
         return filename
     finally:
         if fh is not None:
             fh.close()
         if cleanup is not None:
             if filename and vfs:
                 vfs.unlink(cleanup)
             else:
                 os.unlink(cleanup)
 
 class cg1unpacker(object):
     """Unpacker for cg1 changegroup streams.
 
     A changegroup unpacker handles the framing of the revision data in
     the wire format. Most consumers will want to use the apply()
     method to add the changes from the changegroup to a repository.
 
     If you're forwarding a changegroup unmodified to another consumer,
     use getchunks(), which returns an iterator of changegroup
     chunks. This is mostly useful for cases where you need to know the
     data stream has ended by observing the end of the changegroup.
 
     deltachunk() is useful only if you're applying delta data. Most
     consumers should prefer apply() instead.
 
     A few other public methods exist. Those are used only for
     bundlerepo and some debug commands - their use is discouraged.
     """
     deltaheader = _CHANGEGROUPV1_DELTA_HEADER
     deltaheadersize = deltaheader.size
     version = '01'
     _grouplistcount = 1 # One list of files after the manifests
 
     def __init__(self, fh, alg, extras=None):
         if alg is None:
             alg = 'UN'
         if alg not in util.compengines.supportedbundletypes:
             raise error.Abort(_('unknown stream compression type: %s')
                              % alg)
         if alg == 'BZ':
             alg = '_truncatedBZ'
 
         compengine = util.compengines.forbundletype(alg)
         self._stream = compengine.decompressorreader(fh)
         self._type = alg
         self.extras = extras or {}
         self.callback = None
 
     # These methods (compressed, read, seek, tell) all appear to only
     # be used by bundlerepo, but it's a little hard to tell.
     def compressed(self):
         return self._type is not None and self._type != 'UN'
     def read(self, l):
         return self._stream.read(l)
     def seek(self, pos):
         return self._stream.seek(pos)
     def tell(self):
         return self._stream.tell()
     def close(self):
         return self._stream.close()
 
     def _chunklength(self):
         d = readexactly(self._stream, 4)
         l = struct.unpack(">l", d)[0]
         if l <= 4:
             if l:
                 raise error.Abort(_("invalid chunk length %d") % l)
             return 0
         if self.callback:
             self.callback()
         return l - 4
 
     def changelogheader(self):
         """v10 does not have a changelog header chunk"""
         return {}
 
     def manifestheader(self):
         """v10 does not have a manifest header chunk"""
         return {}
 
     def filelogheader(self):
         """return the header of the filelogs chunk, v10 only has the filename"""
         l = self._chunklength()
         if not l:
             return {}
         fname = readexactly(self._stream, l)
         return {'filename': fname}
 
     def _deltaheader(self, headertuple, prevnode):
         node, p1, p2, cs = headertuple
         if prevnode is None:
             deltabase = p1
         else:
             deltabase = prevnode
         flags = 0
         return node, p1, p2, deltabase, cs, flags
 
     def deltachunk(self, prevnode):
         l = self._chunklength()
         if not l:
             return {}
         headerdata = readexactly(self._stream, self.deltaheadersize)
         header = self.deltaheader.unpack(headerdata)
         delta = readexactly(self._stream, l - self.deltaheadersize)
         node, p1, p2, deltabase, cs, flags = self._deltaheader(header, prevnode)
         return (node, p1, p2, cs, deltabase, delta, flags)
 
     def getchunks(self):
         """returns all the chunks contains in the bundle
 
         Used when you need to forward the binary stream to a file or another
         network API. To do so, it parse the changegroup data, otherwise it will
         block in case of sshrepo because it don't know the end of the stream.
         """
         # For changegroup 1 and 2, we expect 3 parts: changelog, manifestlog,
         # and a list of filelogs. For changegroup 3, we expect 4 parts:
         # changelog, manifestlog, a list of tree manifestlogs, and a list of
         # filelogs.
         #
         # Changelog and manifestlog parts are terminated with empty chunks. The
         # tree and file parts are a list of entry sections. Each entry section
         # is a series of chunks terminating in an empty chunk. The list of these
         # entry sections is terminated in yet another empty chunk, so we know
         # we've reached the end of the tree/file list when we reach an empty
         # chunk that was proceeded by no non-empty chunks.
 
         parts = 0
         while parts < 2 + self._grouplistcount:
             noentries = True
             while True:
                 chunk = getchunk(self)
                 if not chunk:
                     # The first two empty chunks represent the end of the
                     # changelog and the manifestlog portions. The remaining
                     # empty chunks represent either A) the end of individual
                     # tree or file entries in the file list, or B) the end of
                     # the entire list. It's the end of the entire list if there
                     # were no entries (i.e. noentries is True).
                     if parts < 2:
                         parts += 1
                     elif noentries:
                         parts += 1
                     break
                 noentries = False
                 yield chunkheader(len(chunk))
                 pos = 0
                 while pos < len(chunk):
                     next = pos + 2**20
                     yield chunk[pos:next]
                     pos = next
             yield closechunk()
 
     def _unpackmanifests(self, repo, revmap, trp, prog):
         self.callback = prog.increment
         # no need to check for empty manifest group here:
         # if the result of the merge of 1 and 2 is the same in 3 and 4,
         # no new manifest will be created and the manifest group will
         # be empty during the pull
         self.manifestheader()
         deltas = self.deltaiter()
         repo.manifestlog.getstorage(b'').addgroup(deltas, revmap, trp)
         prog.complete()
         self.callback = None
 
     def apply(self, repo, tr, srctype, url, targetphase=phases.draft,
               expectedtotal=None):
         """Add the changegroup returned by source.read() to this repo.
         srctype is a string like 'push', 'pull', or 'unbundle'.  url is
         the URL of the repo where this changegroup is coming from.
 
         Return an integer summarizing the change to this repo:
         - nothing changed or no source: 0
         - more heads than before: 1+added heads (2..n)
         - fewer heads than before: -1-removed heads (-2..-n)
         - number of heads stays the same: 1
         """
         repo = repo.unfiltered()
         def csmap(x):
             repo.ui.debug("add changeset %s\n" % short(x))
             return len(cl)
 
         def revmap(x):
             return cl.rev(x)
 
-        changesets = files = revisions = 0
+        changesets = 0
 
         try:
             # The transaction may already carry source information. In this
             # case we use the top level data. We overwrite the argument
             # because we need to use the top level value (if they exist)
             # in this function.
             srctype = tr.hookargs.setdefault('source', srctype)
             tr.hookargs.setdefault('url', url)
             repo.hook('prechangegroup',
                       throw=True, **pycompat.strkwargs(tr.hookargs))
 
             # write changelog data to temp files so concurrent readers
             # will not see an inconsistent view
             cl = repo.changelog
             cl.delayupdate(tr)
             oldheads = set(cl.heads())
 
             trp = weakref.proxy(tr)
             # pull off the changeset group
             repo.ui.status(_("adding changesets\n"))
             clstart = len(cl)
             progress = repo.ui.makeprogress(_('changesets'), unit=_('chunks'),
                                             total=expectedtotal)
             self.callback = progress.increment
 
             efiles = set()
             def onchangelog(cl, node):
                 efiles.update(cl.readfiles(node))
 
             self.changelogheader()
             deltas = self.deltaiter()
             cgnodes = cl.addgroup(deltas, csmap, trp, addrevisioncb=onchangelog)
             efiles = len(efiles)
 
             if not cgnodes:
                 repo.ui.develwarn('applied empty changelog from changegroup',
                                   config='warn-empty-changegroup')
             clend = len(cl)
             changesets = clend - clstart
             progress.complete()
             self.callback = None
 
             # pull off the manifest group
             repo.ui.status(_("adding manifests\n"))
             # We know that we'll never have more manifests than we had
             # changesets.
             progress = repo.ui.makeprogress(_('manifests'), unit=_('chunks'),
                                             total=changesets)
             self._unpackmanifests(repo, revmap, trp, progress)
 
             needfiles = {}
             if repo.ui.configbool('server', 'validate'):
                 cl = repo.changelog
                 ml = repo.manifestlog
                 # validate incoming csets have their manifests
                 for cset in pycompat.xrange(clstart, clend):
                     mfnode = cl.changelogrevision(cset).manifest
                     mfest = ml[mfnode].readdelta()
                     # store file cgnodes we must see
                     for f, n in mfest.iteritems():
                         needfiles.setdefault(f, set()).add(n)
 
             # process the files
             repo.ui.status(_("adding file changes\n"))
             newrevs, newfiles = _addchangegroupfiles(
                 repo, self, revmap, trp, efiles, needfiles)
-            revisions += newrevs
-            files += newfiles
+
+            # making sure the value exists
+            tr.changes.setdefault('changegroup-count-changesets', 0)
+            tr.changes.setdefault('changegroup-count-revisions', 0)
+            tr.changes.setdefault('changegroup-count-files', 0)
+            tr.changes.setdefault('changegroup-count-heads', 0)
+
+            # some code use bundle operation for internal purpose. They usually
+            # set `ui.quiet` to do this outside of user sight. Size the report
+            # of such operation now happens at the end of the transaction, that
+            # ui.quiet has not direct effect on the output.
+            #
+            # To preserve this intend use an inelegant hack, we fail to report
+            # the change if `quiet` is set. We should probably move to
+            # something better, but this is a good first step to allow the "end
+            # of transaction report" to pass tests.
+            if not repo.ui.quiet:
+                tr.changes['changegroup-count-changesets'] += changesets
+                tr.changes['changegroup-count-revisions'] += newrevs
+                tr.changes['changegroup-count-files'] += newfiles
 
             deltaheads = 0
             if oldheads:
                 heads = cl.heads()
-                deltaheads = len(heads) - len(oldheads)
+                deltaheads += len(heads) - len(oldheads)
                 for h in heads:
                     if h not in oldheads and repo[h].closesbranch():
                         deltaheads -= 1
-            htext = ""
-            if deltaheads:
-                htext = _(" (%+d heads)") % deltaheads
 
-            repo.ui.status(_("added %d changesets"
-                             " with %d changes to %d files%s\n")
-                             % (changesets, revisions, files, htext))
+            # see previous comment about checking ui.quiet
+            if not repo.ui.quiet:
+                tr.changes['changegroup-count-heads'] += deltaheads
             repo.invalidatevolatilesets()
 
             if changesets > 0:
                 if 'node' not in tr.hookargs:
                     tr.hookargs['node'] = hex(cl.node(clstart))
                     tr.hookargs['node_last'] = hex(cl.node(clend - 1))
                     hookargs = dict(tr.hookargs)
                 else:
                     hookargs = dict(tr.hookargs)
                     hookargs['node'] = hex(cl.node(clstart))
                     hookargs['node_last'] = hex(cl.node(clend - 1))
                 repo.hook('pretxnchangegroup',
                           throw=True, **pycompat.strkwargs(hookargs))
 
             added = [cl.node(r) for r in pycompat.xrange(clstart, clend)]
             phaseall = None
             if srctype in ('push', 'serve'):
                 # Old servers can not push the boundary themselves.
                 # New servers won't push the boundary if changeset already
                 # exists locally as secret
                 #
                 # We should not use added here but the list of all change in
                 # the bundle
                 if repo.publishing():
                     targetphase = phaseall = phases.public
                 else:
                     # closer target phase computation
 
                     # Those changesets have been pushed from the
                     # outside, their phases are going to be pushed
                     # alongside. Therefor `targetphase` is
                     # ignored.
                     targetphase = phaseall = phases.draft
             if added:
                 phases.registernew(repo, tr, targetphase, added)
             if phaseall is not None:
                 phases.advanceboundary(repo, tr, phaseall, cgnodes)
 
             if changesets > 0:
 
                 def runhooks():
                     # These hooks run when the lock releases, not when the
                     # transaction closes. So it's possible for the changelog
                     # to have changed since we last saw it.
                     if clstart >= len(repo):
                         return
 
                     repo.hook("changegroup", **pycompat.strkwargs(hookargs))
 
                     for n in added:
                         args = hookargs.copy()
                         args['node'] = hex(n)
                         del args['node_last']
                         repo.hook("incoming", **pycompat.strkwargs(args))
 
                     newheads = [h for h in repo.heads()
                                 if h not in oldheads]
                     repo.ui.log("incoming",
                                 "%d incoming changes - new heads: %s\n",
                                 len(added),
                                 ', '.join([hex(c[:6]) for c in newheads]))
 
                 tr.addpostclose('changegroup-runhooks-%020i' % clstart,
                                 lambda tr: repo._afterlock(runhooks))
         finally:
             repo.ui.flush()
         # never return 0 here:
         if deltaheads < 0:
             ret = deltaheads - 1
         else:
             ret = deltaheads + 1
         return ret
 
     def deltaiter(self):
         """
         returns an iterator of the deltas in this changegroup
 
         Useful for passing to the underlying storage system to be stored.
         """
         chain = None
         for chunkdata in iter(lambda: self.deltachunk(chain), {}):
             # Chunkdata: (node, p1, p2, cs, deltabase, delta, flags)
             yield chunkdata
             chain = chunkdata[0]
 
 class cg2unpacker(cg1unpacker):
     """Unpacker for cg2 streams.
 
     cg2 streams add support for generaldelta, so the delta header
     format is slightly different. All other features about the data
     remain the same.
     """
     deltaheader = _CHANGEGROUPV2_DELTA_HEADER
     deltaheadersize = deltaheader.size
     version = '02'
 
     def _deltaheader(self, headertuple, prevnode):
         node, p1, p2, deltabase, cs = headertuple
         flags = 0
         return node, p1, p2, deltabase, cs, flags
 
 class cg3unpacker(cg2unpacker):
     """Unpacker for cg3 streams.
 
     cg3 streams add support for exchanging treemanifests and revlog
     flags. It adds the revlog flags to the delta header and an empty chunk
     separating manifests and files.
     """
     deltaheader = _CHANGEGROUPV3_DELTA_HEADER
     deltaheadersize = deltaheader.size
     version = '03'
     _grouplistcount = 2 # One list of manifests and one list of files
 
     def _deltaheader(self, headertuple, prevnode):
         node, p1, p2, deltabase, cs, flags = headertuple
         return node, p1, p2, deltabase, cs, flags
 
     def _unpackmanifests(self, repo, revmap, trp, prog):
         super(cg3unpacker, self)._unpackmanifests(repo, revmap, trp, prog)
         for chunkdata in iter(self.filelogheader, {}):
             # If we get here, there are directory manifests in the changegroup
             d = chunkdata["filename"]
             repo.ui.debug("adding %s revisions\n" % d)
             deltas = self.deltaiter()
             if not repo.manifestlog.getstorage(d).addgroup(deltas, revmap, trp):
                 raise error.Abort(_("received dir revlog group is empty"))
 
 class headerlessfixup(object):
     def __init__(self, fh, h):
         self._h = h
         self._fh = fh
     def read(self, n):
         if self._h:
             d, self._h = self._h[:n], self._h[n:]
             if len(d) < n:
                 d += readexactly(self._fh, n - len(d))
             return d
         return readexactly(self._fh, n)
 
 def _revisiondeltatochunks(delta, headerfn):
     """Serialize a revisiondelta to changegroup chunks."""
 
     # The captured revision delta may be encoded as a delta against
     # a base revision or as a full revision. The changegroup format
     # requires that everything on the wire be deltas. So for full
     # revisions, we need to invent a header that says to rewrite
     # data.
 
     if delta.delta is not None:
         prefix, data = b'', delta.delta
     elif delta.basenode == nullid:
         data = delta.revision
         prefix = mdiff.trivialdiffheader(len(data))
     else:
         data = delta.revision
         prefix = mdiff.replacediffheader(delta.baserevisionsize,
                                          len(data))
 
     meta = headerfn(delta)
 
     yield chunkheader(len(meta) + len(prefix) + len(data))
     yield meta
     if prefix:
         yield prefix
     yield data
 
 def _sortnodesellipsis(store, nodes, cl, lookup):
     """Sort nodes for changegroup generation."""
     # Ellipses serving mode.
     #
     # In a perfect world, we'd generate better ellipsis-ified graphs
     # for non-changelog revlogs. In practice, we haven't started doing
     # that yet, so the resulting DAGs for the manifestlog and filelogs
     # are actually full of bogus parentage on all the ellipsis
     # nodes. This has the side effect that, while the contents are
     # correct, the individual DAGs might be completely out of whack in
     # a case like 882681bc3166 and its ancestors (back about 10
     # revisions or so) in the main hg repo.
     #
     # The one invariant we *know* holds is that the new (potentially
     # bogus) DAG shape will be valid if we order the nodes in the
     # order that they're introduced in dramatis personae by the
     # changelog, so what we do is we sort the non-changelog histories
     # by the order in which they are used by the changelog.
     key = lambda n: cl.rev(lookup(n))
     return sorted(nodes, key=key)
 
 def _resolvenarrowrevisioninfo(cl, store, ischangelog, rev, linkrev,
                                linknode, clrevtolocalrev, fullclnodes,
                                precomputedellipsis):
     linkparents = precomputedellipsis[linkrev]
     def local(clrev):
         """Turn a changelog revnum into a local revnum.
 
         The ellipsis dag is stored as revnums on the changelog,
         but when we're producing ellipsis entries for
         non-changelog revlogs, we need to turn those numbers into
         something local. This does that for us, and during the
         changelog sending phase will also expand the stored
         mappings as needed.
         """
         if clrev == nullrev:
             return nullrev
 
         if ischangelog:
             return clrev
 
         # Walk the ellipsis-ized changelog breadth-first looking for a
         # change that has been linked from the current revlog.
         #
         # For a flat manifest revlog only a single step should be necessary
         # as all relevant changelog entries are relevant to the flat
         # manifest.
         #
         # For a filelog or tree manifest dirlog however not every changelog
         # entry will have been relevant, so we need to skip some changelog
         # nodes even after ellipsis-izing.
         walk = [clrev]
         while walk:
             p = walk[0]
             walk = walk[1:]
             if p in clrevtolocalrev:
                 return clrevtolocalrev[p]
             elif p in fullclnodes:
                 walk.extend([pp for pp in cl.parentrevs(p)
                                 if pp != nullrev])
             elif p in precomputedellipsis:
                 walk.extend([pp for pp in precomputedellipsis[p]
                                 if pp != nullrev])
             else:
                 # In this case, we've got an ellipsis with parents
                 # outside the current bundle (likely an
                 # incremental pull). We "know" that we can use the
                 # value of this same revlog at whatever revision
                 # is pointed to by linknode. "Know" is in scare
                 # quotes because I haven't done enough examination
                 # of edge cases to convince myself this is really
                 # a fact - it works for all the (admittedly
                 # thorough) cases in our testsuite, but I would be
                 # somewhat unsurprised to find a case in the wild
                 # where this breaks down a bit. That said, I don't
                 # know if it would hurt anything.
                 for i in pycompat.xrange(rev, 0, -1):
                     if store.linkrev(i) == clrev:
                         return i
                 # We failed to resolve a parent for this node, so
                 # we crash the changegroup construction.
                 raise error.Abort(
                     'unable to resolve parent while packing %r %r'
                     ' for changeset %r' % (store.indexfile, rev, clrev))
 
         return nullrev
 
     if not linkparents or (
         store.parentrevs(rev) == (nullrev, nullrev)):
         p1, p2 = nullrev, nullrev
     elif len(linkparents) == 1:
         p1, = sorted(local(p) for p in linkparents)
         p2 = nullrev
     else:
         p1, p2 = sorted(local(p) for p in linkparents)
 
     p1node, p2node = store.node(p1), store.node(p2)
 
     return p1node, p2node, linknode
 
 def deltagroup(repo, store, nodes, ischangelog, lookup, forcedeltaparentprev,
                topic=None,
                ellipses=False, clrevtolocalrev=None, fullclnodes=None,
                precomputedellipsis=None):
     """Calculate deltas for a set of revisions.
 
     Is a generator of ``revisiondelta`` instances.
 
     If topic is not None, progress detail will be generated using this
     topic name (e.g. changesets, manifests, etc).
     """
     if not nodes:
         return
 
     cl = repo.changelog
 
     if ischangelog:
         # `hg log` shows changesets in storage order. To preserve order
         # across clones, send out changesets in storage order.
         nodesorder = 'storage'
     elif ellipses:
         nodes = _sortnodesellipsis(store, nodes, cl, lookup)
         nodesorder = 'nodes'
     else:
         nodesorder = None
 
     # Perform ellipses filtering and revision massaging. We do this before
     # emitrevisions() because a) filtering out revisions creates less work
     # for emitrevisions() b) dropping revisions would break emitrevisions()'s
     # assumptions about delta choices and we would possibly send a delta
     # referencing a missing base revision.
     #
     # Also, calling lookup() has side-effects with regards to populating
     # data structures. If we don't call lookup() for each node or if we call
     # lookup() after the first pass through each node, things can break -
     # possibly intermittently depending on the python hash seed! For that
     # reason, we store a mapping of all linknodes during the initial node
     # pass rather than use lookup() on the output side.
     if ellipses:
         filtered = []
         adjustedparents = {}
         linknodes = {}
 
         for node in nodes:
             rev = store.rev(node)
             linknode = lookup(node)
             linkrev = cl.rev(linknode)
             clrevtolocalrev[linkrev] = rev
 
             # If linknode is in fullclnodes, it means the corresponding
             # changeset was a full changeset and is being sent unaltered.
             if linknode in fullclnodes:
                 linknodes[node] = linknode
 
             # If the corresponding changeset wasn't in the set computed
             # as relevant to us, it should be dropped outright.
             elif linkrev not in precomputedellipsis:
                 continue
 
             else:
                 # We could probably do this later and avoid the dict
                 # holding state. But it likely doesn't matter.
                 p1node, p2node, linknode = _resolvenarrowrevisioninfo(
                     cl, store, ischangelog, rev, linkrev, linknode,
                     clrevtolocalrev, fullclnodes, precomputedellipsis)
 
                 adjustedparents[node] = (p1node, p2node)
                 linknodes[node] = linknode
 
             filtered.append(node)
 
         nodes = filtered
 
     # We expect the first pass to be fast, so we only engage the progress
     # meter for constructing the revision deltas.
     progress = None
     if topic is not None:
         progress = repo.ui.makeprogress(topic, unit=_('chunks'),
                                         total=len(nodes))
 
     configtarget = repo.ui.config('devel', 'bundle.delta')
     if configtarget not in ('', 'p1', 'full'):
         msg = _("""config "devel.bundle.delta" as unknown value: %s""")
         repo.ui.warn(msg % configtarget)
 
     deltamode = repository.CG_DELTAMODE_STD
     if forcedeltaparentprev:
         deltamode = repository.CG_DELTAMODE_PREV
     elif configtarget == 'p1':
         deltamode = repository.CG_DELTAMODE_P1
     elif configtarget == 'full':
         deltamode = repository.CG_DELTAMODE_FULL
 
     revisions = store.emitrevisions(
         nodes,
         nodesorder=nodesorder,
         revisiondata=True,
         assumehaveparentrevisions=not ellipses,
         deltamode=deltamode)
 
     for i, revision in enumerate(revisions):
         if progress:
             progress.update(i + 1)
 
         if ellipses:
             linknode = linknodes[revision.node]
 
             if revision.node in adjustedparents:
                 p1node, p2node = adjustedparents[revision.node]
                 revision.p1node = p1node
                 revision.p2node = p2node
                 revision.flags |= repository.REVISION_FLAG_ELLIPSIS
 
         else:
             linknode = lookup(revision.node)
 
         revision.linknode = linknode
         yield revision
 
     if progress:
         progress.complete()
 
 class cgpacker(object):
     def __init__(self, repo, oldmatcher, matcher, version,
                  builddeltaheader, manifestsend,
                  forcedeltaparentprev=False,
                  bundlecaps=None, ellipses=False,
                  shallow=False, ellipsisroots=None, fullnodes=None):
         """Given a source repo, construct a bundler.
 
         oldmatcher is a matcher that matches on files the client already has.
         These will not be included in the changegroup.
 
         matcher is a matcher that matches on files to include in the
         changegroup. Used to facilitate sparse changegroups.
 
         forcedeltaparentprev indicates whether delta parents must be against
         the previous revision in a delta group. This should only be used for
         compatibility with changegroup version 1.
 
         builddeltaheader is a callable that constructs the header for a group
         delta.
 
         manifestsend is a chunk to send after manifests have been fully emitted.
 
         ellipses indicates whether ellipsis serving mode is enabled.
 
         bundlecaps is optional and can be used to specify the set of
         capabilities which can be used to build the bundle. While bundlecaps is
         unused in core Mercurial, extensions rely on this feature to communicate
         capabilities to customize the changegroup packer.
 
         shallow indicates whether shallow data might be sent. The packer may
         need to pack file contents not introduced by the changes being packed.
 
         fullnodes is the set of changelog nodes which should not be ellipsis
         nodes. We store this rather than the set of nodes that should be
         ellipsis because for very large histories we expect this to be
         significantly smaller.
         """
         assert oldmatcher
         assert matcher
         self._oldmatcher = oldmatcher
         self._matcher = matcher
 
         self.version = version
         self._forcedeltaparentprev = forcedeltaparentprev
         self._builddeltaheader = builddeltaheader
         self._manifestsend = manifestsend
         self._ellipses = ellipses
 
         # Set of capabilities we can use to build the bundle.
         if bundlecaps is None:
             bundlecaps = set()
         self._bundlecaps = bundlecaps
         self._isshallow = shallow
         self._fullclnodes = fullnodes
 
         # Maps ellipsis revs to their roots at the changelog level.
         self._precomputedellipsis = ellipsisroots
 
         self._repo = repo
 
         if self._repo.ui.verbose and not self._repo.ui.debugflag:
             self._verbosenote = self._repo.ui.note
         else:
             self._verbosenote = lambda s: None
 
     def generate(self, commonrevs, clnodes, fastpathlinkrev, source,
                  changelog=True):
         """Yield a sequence of changegroup byte chunks.
         If changelog is False, changelog data won't be added to changegroup
         """
 
         repo = self._repo
         cl = repo.changelog
 
         self._verbosenote(_('uncompressed size of bundle content:\n'))
         size = 0
 
         clstate, deltas = self._generatechangelog(cl, clnodes,
                                                   generate=changelog)
         for delta in deltas:
             for chunk in _revisiondeltatochunks(delta,
                                                 self._builddeltaheader):
                 size += len(chunk)
                 yield chunk
 
         close = closechunk()
         size += len(close)
         yield closechunk()
 
         self._verbosenote(_('%8.i (changelog)\n') % size)
 
         clrevorder = clstate['clrevorder']
         manifests = clstate['manifests']
         changedfiles = clstate['changedfiles']
 
         # We need to make sure that the linkrev in the changegroup refers to
         # the first changeset that introduced the manifest or file revision.
         # The fastpath is usually safer than the slowpath, because the filelogs
         # are walked in revlog order.
         #
         # When taking the slowpath when the manifest revlog uses generaldelta,
         # the manifest may be walked in the "wrong" order. Without 'clrevorder',
         # we would get an incorrect linkrev (see fix in cc0ff93d0c0c).
         #
         # When taking the fastpath, we are only vulnerable to reordering
         # of the changelog itself. The changelog never uses generaldelta and is
         # never reordered. To handle this case, we simply take the slowpath,
         # which already has the 'clrevorder' logic. This was also fixed in
         # cc0ff93d0c0c.
 
         # Treemanifests don't work correctly with fastpathlinkrev
         # either, because we don't discover which directory nodes to
         # send along with files. This could probably be fixed.
         fastpathlinkrev = fastpathlinkrev and (
             'treemanifest' not in repo.requirements)
 
         fnodes = {}  # needed file nodes
 
         size = 0
         it = self.generatemanifests(
             commonrevs, clrevorder, fastpathlinkrev, manifests, fnodes, source,
             clstate['clrevtomanifestrev'])
 
         for tree, deltas in it:
             if tree:
                 assert self.version == b'03'
                 chunk = _fileheader(tree)
                 size += len(chunk)
                 yield chunk
 
             for delta in deltas:
                 chunks = _revisiondeltatochunks(delta, self._builddeltaheader)
                 for chunk in chunks:
                     size += len(chunk)
                     yield chunk
 
             close = closechunk()
             size += len(close)
             yield close
 
         self._verbosenote(_('%8.i (manifests)\n') % size)
         yield self._manifestsend
 
         mfdicts = None
         if self._ellipses and self._isshallow:
             mfdicts = [(self._repo.manifestlog[n].read(), lr)
                        for (n, lr) in manifests.iteritems()]
 
         manifests.clear()
         clrevs = set(cl.rev(x) for x in clnodes)
 
         it = self.generatefiles(changedfiles, commonrevs,
                                 source, mfdicts, fastpathlinkrev,
                                 fnodes, clrevs)
 
         for path, deltas in it:
             h = _fileheader(path)
             size = len(h)
             yield h
 
             for delta in deltas:
                 chunks = _revisiondeltatochunks(delta, self._builddeltaheader)
                 for chunk in chunks:
                     size += len(chunk)
                     yield chunk
 
             close = closechunk()
             size += len(close)
             yield close
 
             self._verbosenote(_('%8.i  %s\n') % (size, path))
 
         yield closechunk()
 
         if clnodes:
             repo.hook('outgoing', node=hex(clnodes[0]), source=source)
 
     def _generatechangelog(self, cl, nodes, generate=True):
         """Generate data for changelog chunks.
 
         Returns a 2-tuple of a dict containing state and an iterable of
         byte chunks. The state will not be fully populated until the
         chunk stream has been fully consumed.
 
         if generate is False, the state will be fully populated and no chunk
         stream will be yielded
         """
         clrevorder = {}
         manifests = {}
         mfl = self._repo.manifestlog
         changedfiles = set()
         clrevtomanifestrev = {}
 
         state = {
             'clrevorder': clrevorder,
             'manifests': manifests,
             'changedfiles': changedfiles,
             'clrevtomanifestrev': clrevtomanifestrev,
         }
 
         if not (generate or self._ellipses):
             # sort the nodes in storage order
             nodes = sorted(nodes, key=cl.rev)
             for node in nodes:
                 c = cl.changelogrevision(node)
                 clrevorder[node] = len(clrevorder)
                 # record the first changeset introducing this manifest version
                 manifests.setdefault(c.manifest, node)
                 # Record a complete list of potentially-changed files in
                 # this manifest.
                 changedfiles.update(c.files)
 
             return state, ()
 
         # Callback for the changelog, used to collect changed files and
         # manifest nodes.
         # Returns the linkrev node (identity in the changelog case).
         def lookupcl(x):
             c = cl.changelogrevision(x)
             clrevorder[x] = len(clrevorder)
 
             if self._ellipses:
                 # Only update manifests if x is going to be sent. Otherwise we
                 # end up with bogus linkrevs specified for manifests and
                 # we skip some manifest nodes that we should otherwise
                 # have sent.
                 if (x in self._fullclnodes
                     or cl.rev(x) in self._precomputedellipsis):
 
                     manifestnode = c.manifest
                     # Record the first changeset introducing this manifest
                     # version.
                     manifests.setdefault(manifestnode, x)
                     # Set this narrow-specific dict so we have the lowest
                     # manifest revnum to look up for this cl revnum. (Part of
                     # mapping changelog ellipsis parents to manifest ellipsis
                     # parents)
                     clrevtomanifestrev.setdefault(
                         cl.rev(x), mfl.rev(manifestnode))
                 # We can't trust the changed files list in the changeset if the
                 # client requested a shallow clone.
                 if self._isshallow:
                     changedfiles.update(mfl[c.manifest].read().keys())
                 else:
                     changedfiles.update(c.files)
             else:
                 # record the first changeset introducing this manifest version
                 manifests.setdefault(c.manifest, x)
                 # Record a complete list of potentially-changed files in
                 # this manifest.
                 changedfiles.update(c.files)
 
             return x
 
         gen = deltagroup(
             self._repo, cl, nodes, True, lookupcl,
             self._forcedeltaparentprev,
             ellipses=self._ellipses,
             topic=_('changesets'),
             clrevtolocalrev={},
             fullclnodes=self._fullclnodes,
             precomputedellipsis=self._precomputedellipsis)
 
         return state, gen
 
     def generatemanifests(self, commonrevs, clrevorder, fastpathlinkrev,
                           manifests, fnodes, source, clrevtolocalrev):
         """Returns an iterator of changegroup chunks containing manifests.
 
         `source` is unused here, but is used by extensions like remotefilelog to
         change what is sent based in pulls vs pushes, etc.
         """
         repo = self._repo
         mfl = repo.manifestlog
         tmfnodes = {'': manifests}
 
         # Callback for the manifest, used to collect linkrevs for filelog
         # revisions.
         # Returns the linkrev node (collected in lookupcl).
         def makelookupmflinknode(tree, nodes):
             if fastpathlinkrev:
                 assert not tree
                 return manifests.__getitem__
 
             def lookupmflinknode(x):
                 """Callback for looking up the linknode for manifests.
 
                 Returns the linkrev node for the specified manifest.
 
                 SIDE EFFECT:
 
                 1) fclnodes gets populated with the list of relevant
                    file nodes if we're not using fastpathlinkrev
                 2) When treemanifests are in use, collects treemanifest nodes
                    to send
 
                 Note that this means manifests must be completely sent to
                 the client before you can trust the list of files and
                 treemanifests to send.
                 """
                 clnode = nodes[x]
                 mdata = mfl.get(tree, x).readfast(shallow=True)
                 for p, n, fl in mdata.iterentries():
                     if fl == 't': # subdirectory manifest
                         subtree = tree + p + '/'
                         tmfclnodes = tmfnodes.setdefault(subtree, {})
                         tmfclnode = tmfclnodes.setdefault(n, clnode)
                         if clrevorder[clnode] < clrevorder[tmfclnode]:
                             tmfclnodes[n] = clnode
                     else:
                         f = tree + p
                         fclnodes = fnodes.setdefault(f, {})
                         fclnode = fclnodes.setdefault(n, clnode)
                         if clrevorder[clnode] < clrevorder[fclnode]:
                             fclnodes[n] = clnode
                 return clnode
             return lookupmflinknode
 
         while tmfnodes:
             tree, nodes = tmfnodes.popitem()
 
             should_visit = self._matcher.visitdir(tree[:-1])
             if tree and not should_visit:
                 continue
 
             store = mfl.getstorage(tree)
 
             if not should_visit:
                 # No nodes to send because this directory is out of
                 # the client's view of the repository (probably
                 # because of narrow clones). Do this even for the root
                 # directory (tree=='')
                 prunednodes = []
             else:
                 # Avoid sending any manifest nodes we can prove the
                 # client already has by checking linkrevs. See the
                 # related comment in generatefiles().
                 prunednodes = self._prunemanifests(store, nodes, commonrevs)
 
             if tree and not prunednodes:
                 continue
 
             lookupfn = makelookupmflinknode(tree, nodes)
 
             deltas = deltagroup(
                 self._repo, store, prunednodes, False, lookupfn,
                 self._forcedeltaparentprev,
                 ellipses=self._ellipses,
                 topic=_('manifests'),
                 clrevtolocalrev=clrevtolocalrev,
                 fullclnodes=self._fullclnodes,
                 precomputedellipsis=self._precomputedellipsis)
 
             if not self._oldmatcher.visitdir(store.tree[:-1]):
                 yield tree, deltas
             else:
                 # 'deltas' is a generator and we need to consume it even if
                 # we are not going to send it because a side-effect is that
                 # it updates tmdnodes (via lookupfn)
                 for d in deltas:
                     pass
                 if not tree:
                     yield tree, []
 
     def _prunemanifests(self, store, nodes, commonrevs):
         if not self._ellipses:
             # In non-ellipses case and large repositories, it is better to
             # prevent calling of store.rev and store.linkrev on a lot of
             # nodes as compared to sending some extra data
             return nodes.copy()
         # This is split out as a separate method to allow filtering
         # commonrevs in extension code.
         #
         # TODO(augie): this shouldn't be required, instead we should
         # make filtering of revisions to send delegated to the store
         # layer.
         frev, flr = store.rev, store.linkrev
         return [n for n in nodes if flr(frev(n)) not in commonrevs]
 
     # The 'source' parameter is useful for extensions
     def generatefiles(self, changedfiles, commonrevs, source,
                       mfdicts, fastpathlinkrev, fnodes, clrevs):
         changedfiles = [f for f in changedfiles
                         if self._matcher(f) and not self._oldmatcher(f)]
 
         if not fastpathlinkrev:
             def normallinknodes(unused, fname):
                 return fnodes.get(fname, {})
         else:
             cln = self._repo.changelog.node
 
             def normallinknodes(store, fname):
                 flinkrev = store.linkrev
                 fnode = store.node
                 revs = ((r, flinkrev(r)) for r in store)
                 return dict((fnode(r), cln(lr))
                             for r, lr in revs if lr in clrevs)
 
         clrevtolocalrev = {}
 
         if self._isshallow:
             # In a shallow clone, the linknodes callback needs to also include
             # those file nodes that are in the manifests we sent but weren't
             # introduced by those manifests.
             commonctxs = [self._repo[c] for c in commonrevs]
             clrev = self._repo.changelog.rev
 
             def linknodes(flog, fname):
                 for c in commonctxs:
                     try:
                         fnode = c.filenode(fname)
                         clrevtolocalrev[c.rev()] = flog.rev(fnode)
                     except error.ManifestLookupError:
                         pass
                 links = normallinknodes(flog, fname)
                 if len(links) != len(mfdicts):
                     for mf, lr in mfdicts:
                         fnode = mf.get(fname, None)
                         if fnode in links:
                             links[fnode] = min(links[fnode], lr, key=clrev)
                         elif fnode:
                             links[fnode] = lr
                 return links
         else:
             linknodes = normallinknodes
 
         repo = self._repo
         progress = repo.ui.makeprogress(_('files'), unit=_('files'),
                                         total=len(changedfiles))
         for i, fname in enumerate(sorted(changedfiles)):
             filerevlog = repo.file(fname)
             if not filerevlog:
                 raise error.Abort(_("empty or missing file data for %s") %
                                   fname)
 
             clrevtolocalrev.clear()
 
             linkrevnodes = linknodes(filerevlog, fname)
             # Lookup for filenodes, we collected the linkrev nodes above in the
             # fastpath case and with lookupmf in the slowpath case.
             def lookupfilelog(x):
                 return linkrevnodes[x]
 
             frev, flr = filerevlog.rev, filerevlog.linkrev
             # Skip sending any filenode we know the client already
             # has. This avoids over-sending files relatively
             # inexpensively, so it's not a problem if we under-filter
             # here.
             filenodes = [n for n in linkrevnodes
                          if flr(frev(n)) not in commonrevs]
 
             if not filenodes:
                 continue
 
             progress.update(i + 1, item=fname)
 
             deltas = deltagroup(
                 self._repo, filerevlog, filenodes, False, lookupfilelog,
                 self._forcedeltaparentprev,
                 ellipses=self._ellipses,
                 clrevtolocalrev=clrevtolocalrev,
                 fullclnodes=self._fullclnodes,
                 precomputedellipsis=self._precomputedellipsis)
 
             yield fname, deltas
 
         progress.complete()
 
 def _makecg1packer(repo, oldmatcher, matcher, bundlecaps,
                    ellipses=False, shallow=False, ellipsisroots=None,
                    fullnodes=None):
     builddeltaheader = lambda d: _CHANGEGROUPV1_DELTA_HEADER.pack(
         d.node, d.p1node, d.p2node, d.linknode)
 
     return cgpacker(repo, oldmatcher, matcher, b'01',
                     builddeltaheader=builddeltaheader,
                     manifestsend=b'',
                     forcedeltaparentprev=True,
                     bundlecaps=bundlecaps,
                     ellipses=ellipses,
                     shallow=shallow,
                     ellipsisroots=ellipsisroots,
                     fullnodes=fullnodes)
 
 def _makecg2packer(repo, oldmatcher, matcher, bundlecaps,
                    ellipses=False, shallow=False, ellipsisroots=None,
                    fullnodes=None):
     builddeltaheader = lambda d: _CHANGEGROUPV2_DELTA_HEADER.pack(
         d.node, d.p1node, d.p2node, d.basenode, d.linknode)
 
     return cgpacker(repo, oldmatcher, matcher, b'02',
                     builddeltaheader=builddeltaheader,
                     manifestsend=b'',
                     bundlecaps=bundlecaps,
                     ellipses=ellipses,
                     shallow=shallow,
                     ellipsisroots=ellipsisroots,
                     fullnodes=fullnodes)
 
 def _makecg3packer(repo, oldmatcher, matcher, bundlecaps,
                    ellipses=False, shallow=False, ellipsisroots=None,
                    fullnodes=None):
     builddeltaheader = lambda d: _CHANGEGROUPV3_DELTA_HEADER.pack(
         d.node, d.p1node, d.p2node, d.basenode, d.linknode, d.flags)
 
     return cgpacker(repo, oldmatcher, matcher, b'03',
                     builddeltaheader=builddeltaheader,
                     manifestsend=closechunk(),
                     bundlecaps=bundlecaps,
                     ellipses=ellipses,
                     shallow=shallow,
                     ellipsisroots=ellipsisroots,
                     fullnodes=fullnodes)
 
 _packermap = {'01': (_makecg1packer, cg1unpacker),
              # cg2 adds support for exchanging generaldelta
              '02': (_makecg2packer, cg2unpacker),
              # cg3 adds support for exchanging revlog flags and treemanifests
              '03': (_makecg3packer, cg3unpacker),
 }
 
 def allsupportedversions(repo):
     versions = set(_packermap.keys())
     if not (repo.ui.configbool('experimental', 'changegroup3') or
             repo.ui.configbool('experimental', 'treemanifest') or
             'treemanifest' in repo.requirements):
         versions.discard('03')
     return versions
 
 # Changegroup versions that can be applied to the repo
 def supportedincomingversions(repo):
     return allsupportedversions(repo)
 
 # Changegroup versions that can be created from the repo
 def supportedoutgoingversions(repo):
     versions = allsupportedversions(repo)
     if 'treemanifest' in repo.requirements:
         # Versions 01 and 02 support only flat manifests and it's just too
         # expensive to convert between the flat manifest and tree manifest on
         # the fly. Since tree manifests are hashed differently, all of history
         # would have to be converted. Instead, we simply don't even pretend to
         # support versions 01 and 02.
         versions.discard('01')
         versions.discard('02')
     if repository.NARROW_REQUIREMENT in repo.requirements:
         # Versions 01 and 02 don't support revlog flags, and we need to
         # support that for stripping and unbundling to work.
         versions.discard('01')
         versions.discard('02')
     if LFS_REQUIREMENT in repo.requirements:
         # Versions 01 and 02 don't support revlog flags, and we need to
         # mark LFS entries with REVIDX_EXTSTORED.
         versions.discard('01')
         versions.discard('02')
 
     return versions
 
 def localversion(repo):
     # Finds the best version to use for bundles that are meant to be used
     # locally, such as those from strip and shelve, and temporary bundles.
     return max(supportedoutgoingversions(repo))
 
 def safeversion(repo):
     # Finds the smallest version that it's safe to assume clients of the repo
     # will support. For example, all hg versions that support generaldelta also
     # support changegroup 02.
     versions = supportedoutgoingversions(repo)
     if 'generaldelta' in repo.requirements:
         versions.discard('01')
     assert versions
     return min(versions)
 
 def getbundler(version, repo, bundlecaps=None, oldmatcher=None,
                matcher=None, ellipses=False, shallow=False,
                ellipsisroots=None, fullnodes=None):
     assert version in supportedoutgoingversions(repo)
 
     if matcher is None:
         matcher = matchmod.always()
     if oldmatcher is None:
         oldmatcher = matchmod.never()
 
     if version == '01' and not matcher.always():
         raise error.ProgrammingError('version 01 changegroups do not support '
                                      'sparse file matchers')
 
     if ellipses and version in (b'01', b'02'):
         raise error.Abort(
             _('ellipsis nodes require at least cg3 on client and server, '
               'but negotiated version %s') % version)
 
     # Requested files could include files not in the local store. So
     # filter those out.
     matcher = repo.narrowmatch(matcher)
 
     fn = _packermap[version][0]
     return fn(repo, oldmatcher, matcher, bundlecaps, ellipses=ellipses,
               shallow=shallow, ellipsisroots=ellipsisroots,
               fullnodes=fullnodes)
 
 def getunbundler(version, fh, alg, extras=None):
     return _packermap[version][1](fh, alg, extras=extras)
 
 def _changegroupinfo(repo, nodes, source):
     if repo.ui.verbose or source == 'bundle':
         repo.ui.status(_("%d changesets found\n") % len(nodes))
     if repo.ui.debugflag:
         repo.ui.debug("list of changesets:\n")
         for node in nodes:
             repo.ui.debug("%s\n" % hex(node))
 
 def makechangegroup(repo, outgoing, version, source, fastpath=False,
                     bundlecaps=None):
     cgstream = makestream(repo, outgoing, version, source,
                           fastpath=fastpath, bundlecaps=bundlecaps)
     return getunbundler(version, util.chunkbuffer(cgstream), None,
                         {'clcount': len(outgoing.missing) })
 
 def makestream(repo, outgoing, version, source, fastpath=False,
                bundlecaps=None, matcher=None):
     bundler = getbundler(version, repo, bundlecaps=bundlecaps,
                          matcher=matcher)
 
     repo = repo.unfiltered()
     commonrevs = outgoing.common
     csets = outgoing.missing
     heads = outgoing.missingheads
     # We go through the fast path if we get told to, or if all (unfiltered
     # heads have been requested (since we then know there all linkrevs will
     # be pulled by the client).
     heads.sort()
     fastpathlinkrev = fastpath or (
             repo.filtername is None and heads == sorted(repo.heads()))
 
     repo.hook('preoutgoing', throw=True, source=source)
     _changegroupinfo(repo, csets, source)
     return bundler.generate(commonrevs, csets, fastpathlinkrev, source)
 
 def _addchangegroupfiles(repo, source, revmap, trp, expectedfiles, needfiles):
     revisions = 0
     files = 0
     progress = repo.ui.makeprogress(_('files'), unit=_('files'),
                                     total=expectedfiles)
     for chunkdata in iter(source.filelogheader, {}):
         files += 1
         f = chunkdata["filename"]
         repo.ui.debug("adding %s revisions\n" % f)
         progress.increment()
         fl = repo.file(f)
         o = len(fl)
         try:
             deltas = source.deltaiter()
             if not fl.addgroup(deltas, revmap, trp):
                 raise error.Abort(_("received file revlog group is empty"))
         except error.CensoredBaseError as e:
             raise error.Abort(_("received delta base is censored: %s") % e)
         revisions += len(fl) - o
         if f in needfiles:
             needs = needfiles[f]
             for new in pycompat.xrange(o, len(fl)):
                 n = fl.node(new)
                 if n in needs:
                     needs.remove(n)
                 else:
                     raise error.Abort(
                         _("received spurious file revlog entry"))
             if not needs:
                 del needfiles[f]
     progress.complete()
 
     for f, needs in needfiles.iteritems():
         fl = repo.file(f)
         for n in needs:
             try:
                 fl.rev(n)
             except error.LookupError:
                 raise error.Abort(
                     _('missing file data for %s:%s - run hg verify') %
                     (f, hex(n)))
 
     return revisions, files

mercurial/scmutil.py

@@ -1,2007 +1,2021 b''
 # scmutil.py - Mercurial core utility functions
 #
 #  Copyright Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import errno
 import glob
 import hashlib
 import os
 import posixpath
 import re
 import subprocess
 import weakref
 
 from .i18n import _
 from .node import (
     bin,
     hex,
     nullid,
     nullrev,
     short,
     wdirid,
     wdirrev,
 )
 
 from . import (
     copies as copiesmod,
     encoding,
     error,
     match as matchmod,
     obsolete,
     obsutil,
     pathutil,
     phases,
     policy,
     pycompat,
     revsetlang,
     similar,
     smartset,
     url,
     util,
     vfs,
 )
 
 from .utils import (
     procutil,
     stringutil,
 )
 
 if pycompat.iswindows:
     from . import scmwindows as scmplatform
 else:
     from . import scmposix as scmplatform
 
 parsers = policy.importmod(r'parsers')
 
 termsize = scmplatform.termsize
 
 class status(tuple):
     '''Named tuple with a list of files per status. The 'deleted', 'unknown'
        and 'ignored' properties are only relevant to the working copy.
     '''
 
     __slots__ = ()
 
     def __new__(cls, modified, added, removed, deleted, unknown, ignored,
                 clean):
         return tuple.__new__(cls, (modified, added, removed, deleted, unknown,
                                    ignored, clean))
 
     @property
     def modified(self):
         '''files that have been modified'''
         return self[0]
 
     @property
     def added(self):
         '''files that have been added'''
         return self[1]
 
     @property
     def removed(self):
         '''files that have been removed'''
         return self[2]
 
     @property
     def deleted(self):
         '''files that are in the dirstate, but have been deleted from the
            working copy (aka "missing")
         '''
         return self[3]
 
     @property
     def unknown(self):
         '''files not in the dirstate that are not ignored'''
         return self[4]
 
     @property
     def ignored(self):
         '''files not in the dirstate that are ignored (by _dirignore())'''
         return self[5]
 
     @property
     def clean(self):
         '''files that have not been modified'''
         return self[6]
 
     def __repr__(self, *args, **kwargs):
         return ((r'<status modified=%s, added=%s, removed=%s, deleted=%s, '
                  r'unknown=%s, ignored=%s, clean=%s>') %
                 tuple(pycompat.sysstr(stringutil.pprint(v)) for v in self))
 
 def itersubrepos(ctx1, ctx2):
     """find subrepos in ctx1 or ctx2"""
     # Create a (subpath, ctx) mapping where we prefer subpaths from
     # ctx1. The subpaths from ctx2 are important when the .hgsub file
     # has been modified (in ctx2) but not yet committed (in ctx1).
     subpaths = dict.fromkeys(ctx2.substate, ctx2)
     subpaths.update(dict.fromkeys(ctx1.substate, ctx1))
 
     missing = set()
 
     for subpath in ctx2.substate:
         if subpath not in ctx1.substate:
             del subpaths[subpath]
             missing.add(subpath)
 
     for subpath, ctx in sorted(subpaths.iteritems()):
         yield subpath, ctx.sub(subpath)
 
     # Yield an empty subrepo based on ctx1 for anything only in ctx2.  That way,
     # status and diff will have an accurate result when it does
     # 'sub.{status|diff}(rev2)'.  Otherwise, the ctx2 subrepo is compared
     # against itself.
     for subpath in missing:
         yield subpath, ctx2.nullsub(subpath, ctx1)
 
 def nochangesfound(ui, repo, excluded=None):
     '''Report no changes for push/pull, excluded is None or a list of
     nodes excluded from the push/pull.
     '''
     secretlist = []
     if excluded:
         for n in excluded:
             ctx = repo[n]
             if ctx.phase() >= phases.secret and not ctx.extinct():
                 secretlist.append(n)
 
     if secretlist:
         ui.status(_("no changes found (ignored %d secret changesets)\n")
                   % len(secretlist))
     else:
         ui.status(_("no changes found\n"))
 
 def callcatch(ui, func):
     """call func() with global exception handling
 
     return func() if no exception happens. otherwise do some error handling
     and return an exit code accordingly. does not handle all exceptions.
     """
     try:
         try:
             return func()
         except: # re-raises
             ui.traceback()
             raise
     # Global exception handling, alphabetically
     # Mercurial-specific first, followed by built-in and library exceptions
     except error.LockHeld as inst:
         if inst.errno == errno.ETIMEDOUT:
             reason = _('timed out waiting for lock held by %r') % (
                 pycompat.bytestr(inst.locker))
         else:
             reason = _('lock held by %r') % inst.locker
         ui.error(_("abort: %s: %s\n") % (
             inst.desc or stringutil.forcebytestr(inst.filename), reason))
         if not inst.locker:
             ui.error(_("(lock might be very busy)\n"))
     except error.LockUnavailable as inst:
         ui.error(_("abort: could not lock %s: %s\n") %
                  (inst.desc or stringutil.forcebytestr(inst.filename),
                   encoding.strtolocal(inst.strerror)))
     except error.OutOfBandError as inst:
         if inst.args:
             msg = _("abort: remote error:\n")
         else:
             msg = _("abort: remote error\n")
         ui.error(msg)
         if inst.args:
             ui.error(''.join(inst.args))
         if inst.hint:
             ui.error('(%s)\n' % inst.hint)
     except error.RepoError as inst:
         ui.error(_("abort: %s!\n") % inst)
         if inst.hint:
             ui.error(_("(%s)\n") % inst.hint)
     except error.ResponseError as inst:
         ui.error(_("abort: %s") % inst.args[0])
         msg = inst.args[1]
         if isinstance(msg, type(u'')):
             msg = pycompat.sysbytes(msg)
         if not isinstance(msg, bytes):
             ui.error(" %r\n" % (msg,))
         elif not msg:
             ui.error(_(" empty string\n"))
         else:
             ui.error("\n%r\n" % pycompat.bytestr(stringutil.ellipsis(msg)))
     except error.CensoredNodeError as inst:
         ui.error(_("abort: file censored %s!\n") % inst)
     except error.StorageError as inst:
         ui.error(_("abort: %s!\n") % inst)
         if inst.hint:
             ui.error(_("(%s)\n") % inst.hint)
     except error.InterventionRequired as inst:
         ui.error("%s\n" % inst)
         if inst.hint:
             ui.error(_("(%s)\n") % inst.hint)
         return 1
     except error.WdirUnsupported:
         ui.error(_("abort: working directory revision cannot be specified\n"))
     except error.Abort as inst:
         ui.error(_("abort: %s\n") % inst)
         if inst.hint:
             ui.error(_("(%s)\n") % inst.hint)
     except ImportError as inst:
         ui.error(_("abort: %s!\n") % stringutil.forcebytestr(inst))
         m = stringutil.forcebytestr(inst).split()[-1]
         if m in "mpatch bdiff".split():
             ui.error(_("(did you forget to compile extensions?)\n"))
         elif m in "zlib".split():
             ui.error(_("(is your Python install correct?)\n"))
     except (IOError, OSError) as inst:
         if util.safehasattr(inst, "code"): # HTTPError
             ui.error(_("abort: %s\n") % stringutil.forcebytestr(inst))
         elif util.safehasattr(inst, "reason"): # URLError or SSLError
             try: # usually it is in the form (errno, strerror)
                 reason = inst.reason.args[1]
             except (AttributeError, IndexError):
                 # it might be anything, for example a string
                 reason = inst.reason
             if isinstance(reason, pycompat.unicode):
                 # SSLError of Python 2.7.9 contains a unicode
                 reason = encoding.unitolocal(reason)
             ui.error(_("abort: error: %s\n") % reason)
         elif (util.safehasattr(inst, "args")
               and inst.args and inst.args[0] == errno.EPIPE):
             pass
         elif getattr(inst, "strerror", None): # common IOError or OSError
             if getattr(inst, "filename", None) is not None:
                 ui.error(_("abort: %s: '%s'\n") % (
                     encoding.strtolocal(inst.strerror),
                     stringutil.forcebytestr(inst.filename)))
             else:
                 ui.error(_("abort: %s\n") % encoding.strtolocal(inst.strerror))
         else: # suspicious IOError
             raise
     except MemoryError:
         ui.error(_("abort: out of memory\n"))
     except SystemExit as inst:
         # Commands shouldn't sys.exit directly, but give a return code.
         # Just in case catch this and and pass exit code to caller.
         return inst.code
 
     return -1
 
 def checknewlabel(repo, lbl, kind):
     # Do not use the "kind" parameter in ui output.
     # It makes strings difficult to translate.
     if lbl in ['tip', '.', 'null']:
         raise error.Abort(_("the name '%s' is reserved") % lbl)
     for c in (':', '\0', '\n', '\r'):
         if c in lbl:
             raise error.Abort(
                 _("%r cannot be used in a name") % pycompat.bytestr(c))
     try:
         int(lbl)
         raise error.Abort(_("cannot use an integer as a name"))
     except ValueError:
         pass
     if lbl.strip() != lbl:
         raise error.Abort(_("leading or trailing whitespace in name %r") % lbl)
 
 def checkfilename(f):
     '''Check that the filename f is an acceptable filename for a tracked file'''
     if '\r' in f or '\n' in f:
         raise error.Abort(_("'\\n' and '\\r' disallowed in filenames: %r")
                           % pycompat.bytestr(f))
 
 def checkportable(ui, f):
     '''Check if filename f is portable and warn or abort depending on config'''
     checkfilename(f)
     abort, warn = checkportabilityalert(ui)
     if abort or warn:
         msg = util.checkwinfilename(f)
         if msg:
             msg = "%s: %s" % (msg, procutil.shellquote(f))
             if abort:
                 raise error.Abort(msg)
             ui.warn(_("warning: %s\n") % msg)
 
 def checkportabilityalert(ui):
     '''check if the user's config requests nothing, a warning, or abort for
     non-portable filenames'''
     val = ui.config('ui', 'portablefilenames')
     lval = val.lower()
     bval = stringutil.parsebool(val)
     abort = pycompat.iswindows or lval == 'abort'
     warn = bval or lval == 'warn'
     if bval is None and not (warn or abort or lval == 'ignore'):
         raise error.ConfigError(
             _("ui.portablefilenames value is invalid ('%s')") % val)
     return abort, warn
 
 class casecollisionauditor(object):
     def __init__(self, ui, abort, dirstate):
         self._ui = ui
         self._abort = abort
         allfiles = '\0'.join(dirstate._map)
         self._loweredfiles = set(encoding.lower(allfiles).split('\0'))
         self._dirstate = dirstate
         # The purpose of _newfiles is so that we don't complain about
         # case collisions if someone were to call this object with the
         # same filename twice.
         self._newfiles = set()
 
     def __call__(self, f):
         if f in self._newfiles:
             return
         fl = encoding.lower(f)
         if fl in self._loweredfiles and f not in self._dirstate:
             msg = _('possible case-folding collision for %s') % f
             if self._abort:
                 raise error.Abort(msg)
             self._ui.warn(_("warning: %s\n") % msg)
         self._loweredfiles.add(fl)
         self._newfiles.add(f)
 
 def filteredhash(repo, maxrev):
     """build hash of filtered revisions in the current repoview.
 
     Multiple caches perform up-to-date validation by checking that the
     tiprev and tipnode stored in the cache file match the current repository.
     However, this is not sufficient for validating repoviews because the set
     of revisions in the view may change without the repository tiprev and
     tipnode changing.
 
     This function hashes all the revs filtered from the view and returns
     that SHA-1 digest.
     """
     cl = repo.changelog
     if not cl.filteredrevs:
         return None
     key = None
     revs = sorted(r for r in cl.filteredrevs if r <= maxrev)
     if revs:
         s = hashlib.sha1()
         for rev in revs:
             s.update('%d;' % rev)
         key = s.digest()
     return key
 
 def walkrepos(path, followsym=False, seen_dirs=None, recurse=False):
     '''yield every hg repository under path, always recursively.
     The recurse flag will only control recursion into repo working dirs'''
     def errhandler(err):
         if err.filename == path:
             raise err
     samestat = getattr(os.path, 'samestat', None)
     if followsym and samestat is not None:
         def adddir(dirlst, dirname):
             dirstat = os.stat(dirname)
             match = any(samestat(dirstat, lstdirstat) for lstdirstat in dirlst)
             if not match:
                 dirlst.append(dirstat)
             return not match
     else:
         followsym = False
 
     if (seen_dirs is None) and followsym:
         seen_dirs = []
         adddir(seen_dirs, path)
     for root, dirs, files in os.walk(path, topdown=True, onerror=errhandler):
         dirs.sort()
         if '.hg' in dirs:
             yield root # found a repository
             qroot = os.path.join(root, '.hg', 'patches')
             if os.path.isdir(os.path.join(qroot, '.hg')):
                 yield qroot # we have a patch queue repo here
             if recurse:
                 # avoid recursing inside the .hg directory
                 dirs.remove('.hg')
             else:
                 dirs[:] = [] # don't descend further
         elif followsym:
             newdirs = []
             for d in dirs:
                 fname = os.path.join(root, d)
                 if adddir(seen_dirs, fname):
                     if os.path.islink(fname):
                         for hgname in walkrepos(fname, True, seen_dirs):
                             yield hgname
                     else:
                         newdirs.append(d)
             dirs[:] = newdirs
 
 def binnode(ctx):
     """Return binary node id for a given basectx"""
     node = ctx.node()
     if node is None:
         return wdirid
     return node
 
 def intrev(ctx):
     """Return integer for a given basectx that can be used in comparison or
     arithmetic operation"""
     rev = ctx.rev()
     if rev is None:
         return wdirrev
     return rev
 
 def formatchangeid(ctx):
     """Format changectx as '{rev}:{node|formatnode}', which is the default
     template provided by logcmdutil.changesettemplater"""
     repo = ctx.repo()
     return formatrevnode(repo.ui, intrev(ctx), binnode(ctx))
 
 def formatrevnode(ui, rev, node):
     """Format given revision and node depending on the current verbosity"""
     if ui.debugflag:
         hexfunc = hex
     else:
         hexfunc = short
     return '%d:%s' % (rev, hexfunc(node))
 
 def resolvehexnodeidprefix(repo, prefix):
     if (prefix.startswith('x') and
         repo.ui.configbool('experimental', 'revisions.prefixhexnode')):
         prefix = prefix[1:]
     try:
         # Uses unfiltered repo because it's faster when prefix is ambiguous/
         # This matches the shortesthexnodeidprefix() function below.
         node = repo.unfiltered().changelog._partialmatch(prefix)
     except error.AmbiguousPrefixLookupError:
         revset = repo.ui.config('experimental', 'revisions.disambiguatewithin')
         if revset:
             # Clear config to avoid infinite recursion
             configoverrides = {('experimental',
                                 'revisions.disambiguatewithin'): None}
             with repo.ui.configoverride(configoverrides):
                 revs = repo.anyrevs([revset], user=True)
                 matches = []
                 for rev in revs:
                     node = repo.changelog.node(rev)
                     if hex(node).startswith(prefix):
                         matches.append(node)
                 if len(matches) == 1:
                     return matches[0]
         raise
     if node is None:
         return
     repo.changelog.rev(node)  # make sure node isn't filtered
     return node
 
 def mayberevnum(repo, prefix):
     """Checks if the given prefix may be mistaken for a revision number"""
     try:
         i = int(prefix)
         # if we are a pure int, then starting with zero will not be
         # confused as a rev; or, obviously, if the int is larger
         # than the value of the tip rev. We still need to disambiguate if
         # prefix == '0', since that *is* a valid revnum.
         if (prefix != b'0' and prefix[0:1] == b'0') or i >= len(repo):
             return False
         return True
     except ValueError:
         return False
 
 def shortesthexnodeidprefix(repo, node, minlength=1, cache=None):
     """Find the shortest unambiguous prefix that matches hexnode.
 
     If "cache" is not None, it must be a dictionary that can be used for
     caching between calls to this method.
     """
     # _partialmatch() of filtered changelog could take O(len(repo)) time,
     # which would be unacceptably slow. so we look for hash collision in
     # unfiltered space, which means some hashes may be slightly longer.
 
     minlength=max(minlength, 1)
 
     def disambiguate(prefix):
         """Disambiguate against revnums."""
         if repo.ui.configbool('experimental', 'revisions.prefixhexnode'):
             if mayberevnum(repo, prefix):
                 return 'x' + prefix
             else:
                 return prefix
 
         hexnode = hex(node)
         for length in range(len(prefix), len(hexnode) + 1):
             prefix = hexnode[:length]
             if not mayberevnum(repo, prefix):
                 return prefix
 
     cl = repo.unfiltered().changelog
     revset = repo.ui.config('experimental', 'revisions.disambiguatewithin')
     if revset:
         revs = None
         if cache is not None:
             revs = cache.get('disambiguationrevset')
         if revs is None:
             revs = repo.anyrevs([revset], user=True)
             if cache is not None:
                 cache['disambiguationrevset'] = revs
         if cl.rev(node) in revs:
             hexnode = hex(node)
             nodetree = None
             if cache is not None:
                 nodetree = cache.get('disambiguationnodetree')
             if not nodetree:
                 try:
                     nodetree = parsers.nodetree(cl.index, len(revs))
                 except AttributeError:
                     # no native nodetree
                     pass
                 else:
                     for r in revs:
                         nodetree.insert(r)
                     if cache is not None:
                         cache['disambiguationnodetree'] = nodetree
             if nodetree is not None:
                 length = max(nodetree.shortest(node), minlength)
                 prefix = hexnode[:length]
                 return disambiguate(prefix)
             for length in range(minlength, len(hexnode) + 1):
                 matches = []
                 prefix = hexnode[:length]
                 for rev in revs:
                     otherhexnode = repo[rev].hex()
                     if prefix == otherhexnode[:length]:
                         matches.append(otherhexnode)
                 if len(matches) == 1:
                     return disambiguate(prefix)
 
     try:
         return disambiguate(cl.shortest(node, minlength))
     except error.LookupError:
         raise error.RepoLookupError()
 
 def isrevsymbol(repo, symbol):
     """Checks if a symbol exists in the repo.
 
     See revsymbol() for details. Raises error.AmbiguousPrefixLookupError if the
     symbol is an ambiguous nodeid prefix.
     """
     try:
         revsymbol(repo, symbol)
         return True
     except error.RepoLookupError:
         return False
 
 def revsymbol(repo, symbol):
     """Returns a context given a single revision symbol (as string).
 
     This is similar to revsingle(), but accepts only a single revision symbol,
     i.e. things like ".", "tip", "1234", "deadbeef", "my-bookmark" work, but
     not "max(public())".
     """
     if not isinstance(symbol, bytes):
         msg = ("symbol (%s of type %s) was not a string, did you mean "
                "repo[symbol]?" % (symbol, type(symbol)))
         raise error.ProgrammingError(msg)
     try:
         if symbol in ('.', 'tip', 'null'):
             return repo[symbol]
 
         try:
             r = int(symbol)
             if '%d' % r != symbol:
                 raise ValueError
             l = len(repo.changelog)
             if r < 0:
                 r += l
             if r < 0 or r >= l and r != wdirrev:
                 raise ValueError
             return repo[r]
         except error.FilteredIndexError:
             raise
         except (ValueError, OverflowError, IndexError):
             pass
 
         if len(symbol) == 40:
             try:
                 node = bin(symbol)
                 rev = repo.changelog.rev(node)
                 return repo[rev]
             except error.FilteredLookupError:
                 raise
             except (TypeError, LookupError):
                 pass
 
         # look up bookmarks through the name interface
         try:
             node = repo.names.singlenode(repo, symbol)
             rev = repo.changelog.rev(node)
             return repo[rev]
         except KeyError:
             pass
 
         node = resolvehexnodeidprefix(repo, symbol)
         if node is not None:
             rev = repo.changelog.rev(node)
             return repo[rev]
 
         raise error.RepoLookupError(_("unknown revision '%s'") % symbol)
 
     except error.WdirUnsupported:
         return repo[None]
     except (error.FilteredIndexError, error.FilteredLookupError,
             error.FilteredRepoLookupError):
         raise _filterederror(repo, symbol)
 
 def _filterederror(repo, changeid):
     """build an exception to be raised about a filtered changeid
 
     This is extracted in a function to help extensions (eg: evolve) to
     experiment with various message variants."""
     if repo.filtername.startswith('visible'):
 
         # Check if the changeset is obsolete
         unfilteredrepo = repo.unfiltered()
         ctx = revsymbol(unfilteredrepo, changeid)
 
         # If the changeset is obsolete, enrich the message with the reason
         # that made this changeset not visible
         if ctx.obsolete():
             msg = obsutil._getfilteredreason(repo, changeid, ctx)
         else:
             msg = _("hidden revision '%s'") % changeid
 
         hint = _('use --hidden to access hidden revisions')
 
         return error.FilteredRepoLookupError(msg, hint=hint)
     msg = _("filtered revision '%s' (not in '%s' subset)")
     msg %= (changeid, repo.filtername)
     return error.FilteredRepoLookupError(msg)
 
 def revsingle(repo, revspec, default='.', localalias=None):
     if not revspec and revspec != 0:
         return repo[default]
 
     l = revrange(repo, [revspec], localalias=localalias)
     if not l:
         raise error.Abort(_('empty revision set'))
     return repo[l.last()]
 
 def _pairspec(revspec):
     tree = revsetlang.parse(revspec)
     return tree and tree[0] in ('range', 'rangepre', 'rangepost', 'rangeall')
 
 def revpair(repo, revs):
     if not revs:
         return repo['.'], repo[None]
 
     l = revrange(repo, revs)
 
     if not l:
         raise error.Abort(_('empty revision range'))
 
     first = l.first()
     second = l.last()
 
     if (first == second and len(revs) >= 2
         and not all(revrange(repo, [r]) for r in revs)):
         raise error.Abort(_('empty revision on one side of range'))
 
     # if top-level is range expression, the result must always be a pair
     if first == second and len(revs) == 1 and not _pairspec(revs[0]):
         return repo[first], repo[None]
 
     return repo[first], repo[second]
 
 def revrange(repo, specs, localalias=None):
     """Execute 1 to many revsets and return the union.
 
     This is the preferred mechanism for executing revsets using user-specified
     config options, such as revset aliases.
 
     The revsets specified by ``specs`` will be executed via a chained ``OR``
     expression. If ``specs`` is empty, an empty result is returned.
 
     ``specs`` can contain integers, in which case they are assumed to be
     revision numbers.
 
     It is assumed the revsets are already formatted. If you have arguments
     that need to be expanded in the revset, call ``revsetlang.formatspec()``
     and pass the result as an element of ``specs``.
 
     Specifying a single revset is allowed.
 
     Returns a ``revset.abstractsmartset`` which is a list-like interface over
     integer revisions.
     """
     allspecs = []
     for spec in specs:
         if isinstance(spec, int):
             spec = revsetlang.formatspec('%d', spec)
         allspecs.append(spec)
     return repo.anyrevs(allspecs, user=True, localalias=localalias)
 
 def meaningfulparents(repo, ctx):
     """Return list of meaningful (or all if debug) parentrevs for rev.
 
     For merges (two non-nullrev revisions) both parents are meaningful.
     Otherwise the first parent revision is considered meaningful if it
     is not the preceding revision.
     """
     parents = ctx.parents()
     if len(parents) > 1:
         return parents
     if repo.ui.debugflag:
         return [parents[0], repo[nullrev]]
     if parents[0].rev() >= intrev(ctx) - 1:
         return []
     return parents
 
 def getuipathfn(repo, legacyrelativevalue=False, forcerelativevalue=None):
     """Return a function that produced paths for presenting to the user.
 
     The returned function takes a repo-relative path and produces a path
     that can be presented in the UI.
 
     Depending on the value of ui.relative-paths, either a repo-relative or
     cwd-relative path will be produced.
 
     legacyrelativevalue is the value to use if ui.relative-paths=legacy
 
     If forcerelativevalue is not None, then that value will be used regardless
     of what ui.relative-paths is set to.
     """
     if forcerelativevalue is not None:
         relative = forcerelativevalue
     else:
         config = repo.ui.config('ui', 'relative-paths')
         if config == 'legacy':
             relative = legacyrelativevalue
         else:
             relative = stringutil.parsebool(config)
             if relative is None:
                 raise error.ConfigError(
                     _("ui.relative-paths is not a boolean ('%s')") % config)
 
     if relative:
         cwd = repo.getcwd()
         pathto = repo.pathto
         return lambda f: pathto(f, cwd)
     elif repo.ui.configbool('ui', 'slash'):
         return lambda f: f
     else:
         return util.localpath
 
 def subdiruipathfn(subpath, uipathfn):
     '''Create a new uipathfn that treats the file as relative to subpath.'''
     return lambda f: uipathfn(posixpath.join(subpath, f))
 
 def anypats(pats, opts):
     '''Checks if any patterns, including --include and --exclude were given.
 
     Some commands (e.g. addremove) use this condition for deciding whether to
     print absolute or relative paths.
     '''
     return bool(pats or opts.get('include') or opts.get('exclude'))
 
 def expandpats(pats):
     '''Expand bare globs when running on windows.
     On posix we assume it already has already been done by sh.'''
     if not util.expandglobs:
         return list(pats)
     ret = []
     for kindpat in pats:
         kind, pat = matchmod._patsplit(kindpat, None)
         if kind is None:
             try:
                 globbed = glob.glob(pat)
             except re.error:
                 globbed = [pat]
             if globbed:
                 ret.extend(globbed)
                 continue
         ret.append(kindpat)
     return ret
 
 def matchandpats(ctx, pats=(), opts=None, globbed=False, default='relpath',
                  badfn=None):
     '''Return a matcher and the patterns that were used.
     The matcher will warn about bad matches, unless an alternate badfn callback
     is provided.'''
     if opts is None:
         opts = {}
     if not globbed and default == 'relpath':
         pats = expandpats(pats or [])
 
     uipathfn = getuipathfn(ctx.repo(), legacyrelativevalue=True)
     def bad(f, msg):
         ctx.repo().ui.warn("%s: %s\n" % (uipathfn(f), msg))
 
     if badfn is None:
         badfn = bad
 
     m = ctx.match(pats, opts.get('include'), opts.get('exclude'),
                   default, listsubrepos=opts.get('subrepos'), badfn=badfn)
 
     if m.always():
         pats = []
     return m, pats
 
 def match(ctx, pats=(), opts=None, globbed=False, default='relpath',
           badfn=None):
     '''Return a matcher that will warn about bad matches.'''
     return matchandpats(ctx, pats, opts, globbed, default, badfn=badfn)[0]
 
 def matchall(repo):
     '''Return a matcher that will efficiently match everything.'''
     return matchmod.always()
 
 def matchfiles(repo, files, badfn=None):
     '''Return a matcher that will efficiently match exactly these files.'''
     return matchmod.exact(files, badfn=badfn)
 
 def parsefollowlinespattern(repo, rev, pat, msg):
     """Return a file name from `pat` pattern suitable for usage in followlines
     logic.
     """
     if not matchmod.patkind(pat):
         return pathutil.canonpath(repo.root, repo.getcwd(), pat)
     else:
         ctx = repo[rev]
         m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=ctx)
         files = [f for f in ctx if m(f)]
         if len(files) != 1:
             raise error.ParseError(msg)
         return files[0]
 
 def getorigvfs(ui, repo):
     """return a vfs suitable to save 'orig' file
 
     return None if no special directory is configured"""
     origbackuppath = ui.config('ui', 'origbackuppath')
     if not origbackuppath:
         return None
     return vfs.vfs(repo.wvfs.join(origbackuppath))
 
 def backuppath(ui, repo, filepath):
     '''customize where working copy backup files (.orig files) are created
 
     Fetch user defined path from config file: [ui] origbackuppath = <path>
     Fall back to default (filepath with .orig suffix) if not specified
 
     filepath is repo-relative
 
     Returns an absolute path
     '''
     origvfs = getorigvfs(ui, repo)
     if origvfs is None:
         return repo.wjoin(filepath + ".orig")
 
     origbackupdir = origvfs.dirname(filepath)
     if not origvfs.isdir(origbackupdir) or origvfs.islink(origbackupdir):
         ui.note(_('creating directory: %s\n') % origvfs.join(origbackupdir))
 
         # Remove any files that conflict with the backup file's path
         for f in reversed(list(util.finddirs(filepath))):
             if origvfs.isfileorlink(f):
                 ui.note(_('removing conflicting file: %s\n')
                         % origvfs.join(f))
                 origvfs.unlink(f)
                 break
 
         origvfs.makedirs(origbackupdir)
 
     if origvfs.isdir(filepath) and not origvfs.islink(filepath):
         ui.note(_('removing conflicting directory: %s\n')
                 % origvfs.join(filepath))
         origvfs.rmtree(filepath, forcibly=True)
 
     return origvfs.join(filepath)
 
 class _containsnode(object):
     """proxy __contains__(node) to container.__contains__ which accepts revs"""
 
     def __init__(self, repo, revcontainer):
         self._torev = repo.changelog.rev
         self._revcontains = revcontainer.__contains__
 
     def __contains__(self, node):
         return self._revcontains(self._torev(node))
 
 def cleanupnodes(repo, replacements, operation, moves=None, metadata=None,
                  fixphase=False, targetphase=None, backup=True):
     """do common cleanups when old nodes are replaced by new nodes
 
     That includes writing obsmarkers or stripping nodes, and moving bookmarks.
     (we might also want to move working directory parent in the future)
 
     By default, bookmark moves are calculated automatically from 'replacements',
     but 'moves' can be used to override that. Also, 'moves' may include
     additional bookmark moves that should not have associated obsmarkers.
 
     replacements is {oldnode: [newnode]} or a iterable of nodes if they do not
     have replacements. operation is a string, like "rebase".
 
     metadata is dictionary containing metadata to be stored in obsmarker if
     obsolescence is enabled.
     """
     assert fixphase or targetphase is None
     if not replacements and not moves:
         return
 
     # translate mapping's other forms
     if not util.safehasattr(replacements, 'items'):
         replacements = {(n,): () for n in replacements}
     else:
         # upgrading non tuple "source" to tuple ones for BC
         repls = {}
         for key, value in replacements.items():
             if not isinstance(key, tuple):
                 key = (key,)
             repls[key] = value
         replacements = repls
 
     # Unfiltered repo is needed since nodes in replacements might be hidden.
     unfi = repo.unfiltered()
 
     # Calculate bookmark movements
     if moves is None:
         moves = {}
         for oldnodes, newnodes in replacements.items():
             for oldnode in oldnodes:
                 if oldnode in moves:
                     continue
                 if len(newnodes) > 1:
                     # usually a split, take the one with biggest rev number
                     newnode = next(unfi.set('max(%ln)', newnodes)).node()
                 elif len(newnodes) == 0:
                     # move bookmark backwards
                     allreplaced = []
                     for rep in replacements:
                         allreplaced.extend(rep)
                     roots = list(unfi.set('max((::%n) - %ln)', oldnode,
                                           allreplaced))
                     if roots:
                         newnode = roots[0].node()
                     else:
                         newnode = nullid
                 else:
                     newnode = newnodes[0]
                 moves[oldnode] = newnode
 
     allnewnodes = [n for ns in replacements.values() for n in ns]
     toretract = {}
     toadvance = {}
     if fixphase:
         precursors = {}
         for oldnodes, newnodes in replacements.items():
             for oldnode in oldnodes:
                 for newnode in newnodes:
                     precursors.setdefault(newnode, []).append(oldnode)
 
         allnewnodes.sort(key=lambda n: unfi[n].rev())
         newphases = {}
         def phase(ctx):
             return newphases.get(ctx.node(), ctx.phase())
         for newnode in allnewnodes:
             ctx = unfi[newnode]
             parentphase = max(phase(p) for p in ctx.parents())
             if targetphase is None:
                 oldphase = max(unfi[oldnode].phase()
                                for oldnode in precursors[newnode])
                 newphase = max(oldphase, parentphase)
             else:
                 newphase = max(targetphase, parentphase)
             newphases[newnode] = newphase
             if newphase > ctx.phase():
                 toretract.setdefault(newphase, []).append(newnode)
             elif newphase < ctx.phase():
                 toadvance.setdefault(newphase, []).append(newnode)
 
     with repo.transaction('cleanup') as tr:
         # Move bookmarks
         bmarks = repo._bookmarks
         bmarkchanges = []
         for oldnode, newnode in moves.items():
             oldbmarks = repo.nodebookmarks(oldnode)
             if not oldbmarks:
                 continue
             from . import bookmarks # avoid import cycle
             repo.ui.debug('moving bookmarks %r from %s to %s\n' %
                           (pycompat.rapply(pycompat.maybebytestr, oldbmarks),
                            hex(oldnode), hex(newnode)))
             # Delete divergent bookmarks being parents of related newnodes
             deleterevs = repo.revs('parents(roots(%ln & (::%n))) - parents(%n)',
                                    allnewnodes, newnode, oldnode)
             deletenodes = _containsnode(repo, deleterevs)
             for name in oldbmarks:
                 bmarkchanges.append((name, newnode))
                 for b in bookmarks.divergent2delete(repo, deletenodes, name):
                     bmarkchanges.append((b, None))
 
         if bmarkchanges:
             bmarks.applychanges(repo, tr, bmarkchanges)
 
         for phase, nodes in toretract.items():
             phases.retractboundary(repo, tr, phase, nodes)
         for phase, nodes in toadvance.items():
             phases.advanceboundary(repo, tr, phase, nodes)
 
         mayusearchived = repo.ui.config('experimental', 'cleanup-as-archived')
         # Obsolete or strip nodes
         if obsolete.isenabled(repo, obsolete.createmarkersopt):
             # If a node is already obsoleted, and we want to obsolete it
             # without a successor, skip that obssolete request since it's
             # unnecessary. That's the "if s or not isobs(n)" check below.
             # Also sort the node in topology order, that might be useful for
             # some obsstore logic.
             # NOTE: the sorting might belong to createmarkers.
             torev = unfi.changelog.rev
             sortfunc = lambda ns: torev(ns[0][0])
             rels = []
             for ns, s in sorted(replacements.items(), key=sortfunc):
                 rel = (tuple(unfi[n] for n in ns), tuple(unfi[m] for m in s))
                 rels.append(rel)
             if rels:
                 obsolete.createmarkers(repo, rels, operation=operation,
                                        metadata=metadata)
         elif phases.supportinternal(repo) and mayusearchived:
             # this assume we do not have "unstable" nodes above the cleaned ones
             allreplaced = set()
             for ns in replacements.keys():
                 allreplaced.update(ns)
             if backup:
                 from . import repair # avoid import cycle
                 node = min(allreplaced, key=repo.changelog.rev)
                 repair.backupbundle(repo, allreplaced, allreplaced, node,
                                     operation)
             phases.retractboundary(repo, tr, phases.archived, allreplaced)
         else:
             from . import repair # avoid import cycle
             tostrip = list(n for ns in replacements for n in ns)
             if tostrip:
                 repair.delayedstrip(repo.ui, repo, tostrip, operation,
                                     backup=backup)
 
 def addremove(repo, matcher, prefix, uipathfn, opts=None):
     if opts is None:
         opts = {}
     m = matcher
     dry_run = opts.get('dry_run')
     try:
         similarity = float(opts.get('similarity') or 0)
     except ValueError:
         raise error.Abort(_('similarity must be a number'))
     if similarity < 0 or similarity > 100:
         raise error.Abort(_('similarity must be between 0 and 100'))
     similarity /= 100.0
 
     ret = 0
 
     wctx = repo[None]
     for subpath in sorted(wctx.substate):
         submatch = matchmod.subdirmatcher(subpath, m)
         if opts.get('subrepos') or m.exact(subpath) or any(submatch.files()):
             sub = wctx.sub(subpath)
             subprefix = repo.wvfs.reljoin(prefix, subpath)
             subuipathfn = subdiruipathfn(subpath, uipathfn)
             try:
                 if sub.addremove(submatch, subprefix, subuipathfn, opts):
                     ret = 1
             except error.LookupError:
                 repo.ui.status(_("skipping missing subrepository: %s\n")
                                  % uipathfn(subpath))
 
     rejected = []
     def badfn(f, msg):
         if f in m.files():
             m.bad(f, msg)
         rejected.append(f)
 
     badmatch = matchmod.badmatch(m, badfn)
     added, unknown, deleted, removed, forgotten = _interestingfiles(repo,
                                                                     badmatch)
 
     unknownset = set(unknown + forgotten)
     toprint = unknownset.copy()
     toprint.update(deleted)
     for abs in sorted(toprint):
         if repo.ui.verbose or not m.exact(abs):
             if abs in unknownset:
                 status = _('adding %s\n') % uipathfn(abs)
                 label = 'ui.addremove.added'
             else:
                 status = _('removing %s\n') % uipathfn(abs)
                 label = 'ui.addremove.removed'
             repo.ui.status(status, label=label)
 
     renames = _findrenames(repo, m, added + unknown, removed + deleted,
                            similarity, uipathfn)
 
     if not dry_run:
         _markchanges(repo, unknown + forgotten, deleted, renames)
 
     for f in rejected:
         if f in m.files():
             return 1
     return ret
 
 def marktouched(repo, files, similarity=0.0):
     '''Assert that files have somehow been operated upon. files are relative to
     the repo root.'''
     m = matchfiles(repo, files, badfn=lambda x, y: rejected.append(x))
     rejected = []
 
     added, unknown, deleted, removed, forgotten = _interestingfiles(repo, m)
 
     if repo.ui.verbose:
         unknownset = set(unknown + forgotten)
         toprint = unknownset.copy()
         toprint.update(deleted)
         for abs in sorted(toprint):
             if abs in unknownset:
                 status = _('adding %s\n') % abs
             else:
                 status = _('removing %s\n') % abs
             repo.ui.status(status)
 
     # TODO: We should probably have the caller pass in uipathfn and apply it to
     # the messages above too. legacyrelativevalue=True is consistent with how
     # it used to work.
     uipathfn = getuipathfn(repo, legacyrelativevalue=True)
     renames = _findrenames(repo, m, added + unknown, removed + deleted,
                            similarity, uipathfn)
 
     _markchanges(repo, unknown + forgotten, deleted, renames)
 
     for f in rejected:
         if f in m.files():
             return 1
     return 0
 
 def _interestingfiles(repo, matcher):
     '''Walk dirstate with matcher, looking for files that addremove would care
     about.
 
     This is different from dirstate.status because it doesn't care about
     whether files are modified or clean.'''
     added, unknown, deleted, removed, forgotten = [], [], [], [], []
     audit_path = pathutil.pathauditor(repo.root, cached=True)
 
     ctx = repo[None]
     dirstate = repo.dirstate
     matcher = repo.narrowmatch(matcher, includeexact=True)
     walkresults = dirstate.walk(matcher, subrepos=sorted(ctx.substate),
                                 unknown=True, ignored=False, full=False)
     for abs, st in walkresults.iteritems():
         dstate = dirstate[abs]
         if dstate == '?' and audit_path.check(abs):
             unknown.append(abs)
         elif dstate != 'r' and not st:
             deleted.append(abs)
         elif dstate == 'r' and st:
             forgotten.append(abs)
         # for finding renames
         elif dstate == 'r' and not st:
             removed.append(abs)
         elif dstate == 'a':
             added.append(abs)
 
     return added, unknown, deleted, removed, forgotten
 
 def _findrenames(repo, matcher, added, removed, similarity, uipathfn):
     '''Find renames from removed files to added ones.'''
     renames = {}
     if similarity > 0:
         for old, new, score in similar.findrenames(repo, added, removed,
                                                    similarity):
             if (repo.ui.verbose or not matcher.exact(old)
                 or not matcher.exact(new)):
                 repo.ui.status(_('recording removal of %s as rename to %s '
                                  '(%d%% similar)\n') %
                                (uipathfn(old), uipathfn(new),
                                 score * 100))
             renames[new] = old
     return renames
 
 def _markchanges(repo, unknown, deleted, renames):
     '''Marks the files in unknown as added, the files in deleted as removed,
     and the files in renames as copied.'''
     wctx = repo[None]
     with repo.wlock():
         wctx.forget(deleted)
         wctx.add(unknown)
         for new, old in renames.iteritems():
             wctx.copy(old, new)
 
 def getrenamedfn(repo, endrev=None):
     if copiesmod.usechangesetcentricalgo(repo):
         def getrenamed(fn, rev):
             ctx = repo[rev]
             p1copies = ctx.p1copies()
             if fn in p1copies:
                 return p1copies[fn]
             p2copies = ctx.p2copies()
             if fn in p2copies:
                 return p2copies[fn]
             return None
         return getrenamed
 
     rcache = {}
     if endrev is None:
         endrev = len(repo)
 
     def getrenamed(fn, rev):
         '''looks up all renames for a file (up to endrev) the first
         time the file is given. It indexes on the changerev and only
         parses the manifest if linkrev != changerev.
         Returns rename info for fn at changerev rev.'''
         if fn not in rcache:
             rcache[fn] = {}
             fl = repo.file(fn)
             for i in fl:
                 lr = fl.linkrev(i)
                 renamed = fl.renamed(fl.node(i))
                 rcache[fn][lr] = renamed and renamed[0]
                 if lr >= endrev:
                     break
         if rev in rcache[fn]:
             return rcache[fn][rev]
 
         # If linkrev != rev (i.e. rev not found in rcache) fallback to
         # filectx logic.
         try:
             return repo[rev][fn].copysource()
         except error.LookupError:
             return None
 
     return getrenamed
 
 def getcopiesfn(repo, endrev=None):
     if copiesmod.usechangesetcentricalgo(repo):
         def copiesfn(ctx):
             if ctx.p2copies():
                 allcopies = ctx.p1copies().copy()
                 # There should be no overlap
                 allcopies.update(ctx.p2copies())
                 return sorted(allcopies.items())
             else:
                 return sorted(ctx.p1copies().items())
     else:
         getrenamed = getrenamedfn(repo, endrev)
         def copiesfn(ctx):
             copies = []
             for fn in ctx.files():
                 rename = getrenamed(fn, ctx.rev())
                 if rename:
                     copies.append((fn, rename))
             return copies
 
     return copiesfn
 
 def dirstatecopy(ui, repo, wctx, src, dst, dryrun=False, cwd=None):
     """Update the dirstate to reflect the intent of copying src to dst. For
     different reasons it might not end with dst being marked as copied from src.
     """
     origsrc = repo.dirstate.copied(src) or src
     if dst == origsrc: # copying back a copy?
         if repo.dirstate[dst] not in 'mn' and not dryrun:
             repo.dirstate.normallookup(dst)
     else:
         if repo.dirstate[origsrc] == 'a' and origsrc == src:
             if not ui.quiet:
                 ui.warn(_("%s has not been committed yet, so no copy "
                           "data will be stored for %s.\n")
                         % (repo.pathto(origsrc, cwd), repo.pathto(dst, cwd)))
             if repo.dirstate[dst] in '?r' and not dryrun:
                 wctx.add([dst])
         elif not dryrun:
             wctx.copy(origsrc, dst)
 
 def movedirstate(repo, newctx, match=None):
     """Move the dirstate to newctx and adjust it as necessary.
 
     A matcher can be provided as an optimization. It is probably a bug to pass
     a matcher that doesn't match all the differences between the parent of the
     working copy and newctx.
     """
     oldctx = repo['.']
     ds = repo.dirstate
     ds.setparents(newctx.node(), nullid)
     copies = dict(ds.copies())
     s = newctx.status(oldctx, match=match)
     for f in s.modified:
         if ds[f] == 'r':
             # modified + removed -> removed
             continue
         ds.normallookup(f)
 
     for f in s.added:
         if ds[f] == 'r':
             # added + removed -> unknown
             ds.drop(f)
         elif ds[f] != 'a':
             ds.add(f)
 
     for f in s.removed:
         if ds[f] == 'a':
             # removed + added -> normal
             ds.normallookup(f)
         elif ds[f] != 'r':
             ds.remove(f)
 
     # Merge old parent and old working dir copies
     oldcopies = copiesmod.pathcopies(newctx, oldctx, match)
     oldcopies.update(copies)
     copies = dict((dst, oldcopies.get(src, src))
                   for dst, src in oldcopies.iteritems())
     # Adjust the dirstate copies
     for dst, src in copies.iteritems():
         if (src not in newctx or dst in newctx or ds[dst] != 'a'):
             src = None
         ds.copy(src, dst)
 
 def writerequires(opener, requirements):
     with opener('requires', 'w', atomictemp=True) as fp:
         for r in sorted(requirements):
             fp.write("%s\n" % r)
 
 class filecachesubentry(object):
     def __init__(self, path, stat):
         self.path = path
         self.cachestat = None
         self._cacheable = None
 
         if stat:
             self.cachestat = filecachesubentry.stat(self.path)
 
             if self.cachestat:
                 self._cacheable = self.cachestat.cacheable()
             else:
                 # None means we don't know yet
                 self._cacheable = None
 
     def refresh(self):
         if self.cacheable():
             self.cachestat = filecachesubentry.stat(self.path)
 
     def cacheable(self):
         if self._cacheable is not None:
             return self._cacheable
 
         # we don't know yet, assume it is for now
         return True
 
     def changed(self):
         # no point in going further if we can't cache it
         if not self.cacheable():
             return True
 
         newstat = filecachesubentry.stat(self.path)
 
         # we may not know if it's cacheable yet, check again now
         if newstat and self._cacheable is None:
             self._cacheable = newstat.cacheable()
 
             # check again
             if not self._cacheable:
                 return True
 
         if self.cachestat != newstat:
             self.cachestat = newstat
             return True
         else:
             return False
 
     @staticmethod
     def stat(path):
         try:
             return util.cachestat(path)
         except OSError as e:
             if e.errno != errno.ENOENT:
                 raise
 
 class filecacheentry(object):
     def __init__(self, paths, stat=True):
         self._entries = []
         for path in paths:
             self._entries.append(filecachesubentry(path, stat))
 
     def changed(self):
         '''true if any entry has changed'''
         for entry in self._entries:
             if entry.changed():
                 return True
         return False
 
     def refresh(self):
         for entry in self._entries:
             entry.refresh()
 
 class filecache(object):
     """A property like decorator that tracks files under .hg/ for updates.
 
     On first access, the files defined as arguments are stat()ed and the
     results cached. The decorated function is called. The results are stashed
     away in a ``_filecache`` dict on the object whose method is decorated.
 
     On subsequent access, the cached result is used as it is set to the
     instance dictionary.
 
     On external property set/delete operations, the caller must update the
     corresponding _filecache entry appropriately. Use __class__.<attr>.set()
     instead of directly setting <attr>.
 
     When using the property API, the cached data is always used if available.
     No stat() is performed to check if the file has changed.
 
     Others can muck about with the state of the ``_filecache`` dict. e.g. they
     can populate an entry before the property's getter is called. In this case,
     entries in ``_filecache`` will be used during property operations,
     if available. If the underlying file changes, it is up to external callers
     to reflect this by e.g. calling ``delattr(obj, attr)`` to remove the cached
     method result as well as possibly calling ``del obj._filecache[attr]`` to
     remove the ``filecacheentry``.
     """
 
     def __init__(self, *paths):
         self.paths = paths
 
     def join(self, obj, fname):
         """Used to compute the runtime path of a cached file.
 
         Users should subclass filecache and provide their own version of this
         function to call the appropriate join function on 'obj' (an instance
         of the class that its member function was decorated).
         """
         raise NotImplementedError
 
     def __call__(self, func):
         self.func = func
         self.sname = func.__name__
         self.name = pycompat.sysbytes(self.sname)
         return self
 
     def __get__(self, obj, type=None):
         # if accessed on the class, return the descriptor itself.
         if obj is None:
             return self
 
         assert self.sname not in obj.__dict__
 
         entry = obj._filecache.get(self.name)
 
         if entry:
             if entry.changed():
                 entry.obj = self.func(obj)
         else:
             paths = [self.join(obj, path) for path in self.paths]
 
             # We stat -before- creating the object so our cache doesn't lie if
             # a writer modified between the time we read and stat
             entry = filecacheentry(paths, True)
             entry.obj = self.func(obj)
 
             obj._filecache[self.name] = entry
 
         obj.__dict__[self.sname] = entry.obj
         return entry.obj
 
     # don't implement __set__(), which would make __dict__ lookup as slow as
     # function call.
 
     def set(self, obj, value):
         if self.name not in obj._filecache:
             # we add an entry for the missing value because X in __dict__
             # implies X in _filecache
             paths = [self.join(obj, path) for path in self.paths]
             ce = filecacheentry(paths, False)
             obj._filecache[self.name] = ce
         else:
             ce = obj._filecache[self.name]
 
         ce.obj = value # update cached copy
         obj.__dict__[self.sname] = value # update copy returned by obj.x
 
 def extdatasource(repo, source):
     """Gather a map of rev -> value dict from the specified source
 
     A source spec is treated as a URL, with a special case shell: type
     for parsing the output from a shell command.
 
     The data is parsed as a series of newline-separated records where
     each record is a revision specifier optionally followed by a space
     and a freeform string value. If the revision is known locally, it
     is converted to a rev, otherwise the record is skipped.
 
     Note that both key and value are treated as UTF-8 and converted to
     the local encoding. This allows uniformity between local and
     remote data sources.
     """
 
     spec = repo.ui.config("extdata", source)
     if not spec:
         raise error.Abort(_("unknown extdata source '%s'") % source)
 
     data = {}
     src = proc = None
     try:
         if spec.startswith("shell:"):
             # external commands should be run relative to the repo root
             cmd = spec[6:]
             proc = subprocess.Popen(procutil.tonativestr(cmd),
                                     shell=True, bufsize=-1,
                                     close_fds=procutil.closefds,
                                     stdout=subprocess.PIPE,
                                     cwd=procutil.tonativestr(repo.root))
             src = proc.stdout
         else:
             # treat as a URL or file
             src = url.open(repo.ui, spec)
         for l in src:
             if " " in l:
                 k, v = l.strip().split(" ", 1)
             else:
                 k, v = l.strip(), ""
 
             k = encoding.tolocal(k)
             try:
                 data[revsingle(repo, k).rev()] = encoding.tolocal(v)
             except (error.LookupError, error.RepoLookupError):
                 pass # we ignore data for nodes that don't exist locally
     finally:
         if proc:
             try:
                 proc.communicate()
             except ValueError:
                 # This happens if we started iterating src and then
                 # get a parse error on a line. It should be safe to ignore.
                 pass
         if src:
             src.close()
     if proc and proc.returncode != 0:
         raise error.Abort(_("extdata command '%s' failed: %s")
                           % (cmd, procutil.explainexit(proc.returncode)))
 
     return data
 
 def _locksub(repo, lock, envvar, cmd, environ=None, *args, **kwargs):
     if lock is None:
         raise error.LockInheritanceContractViolation(
             'lock can only be inherited while held')
     if environ is None:
         environ = {}
     with lock.inherit() as locker:
         environ[envvar] = locker
         return repo.ui.system(cmd, environ=environ, *args, **kwargs)
 
 def wlocksub(repo, cmd, *args, **kwargs):
     """run cmd as a subprocess that allows inheriting repo's wlock
 
     This can only be called while the wlock is held. This takes all the
     arguments that ui.system does, and returns the exit code of the
     subprocess."""
     return _locksub(repo, repo.currentwlock(), 'HG_WLOCK_LOCKER', cmd, *args,
                     **kwargs)
 
 class progress(object):
     def __init__(self, ui, updatebar, topic, unit="", total=None):
         self.ui = ui
         self.pos = 0
         self.topic = topic
         self.unit = unit
         self.total = total
         self.debug = ui.configbool('progress', 'debug')
         self._updatebar = updatebar
 
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_value, exc_tb):
         self.complete()
 
     def update(self, pos, item="", total=None):
         assert pos is not None
         if total:
             self.total = total
         self.pos = pos
         self._updatebar(self.topic, self.pos, item, self.unit, self.total)
         if self.debug:
             self._printdebug(item)
 
     def increment(self, step=1, item="", total=None):
         self.update(self.pos + step, item, total)
 
     def complete(self):
         self.pos = None
         self.unit = ""
         self.total = None
         self._updatebar(self.topic, self.pos, "", self.unit, self.total)
 
     def _printdebug(self, item):
         if self.unit:
             unit = ' ' + self.unit
         if item:
             item = ' ' + item
 
         if self.total:
             pct = 100.0 * self.pos / self.total
             self.ui.debug('%s:%s %d/%d%s (%4.2f%%)\n'
                        % (self.topic, item, self.pos, self.total, unit, pct))
         else:
             self.ui.debug('%s:%s %d%s\n' % (self.topic, item, self.pos, unit))
 
 def gdinitconfig(ui):
     """helper function to know if a repo should be created as general delta
     """
     # experimental config: format.generaldelta
     return (ui.configbool('format', 'generaldelta')
             or ui.configbool('format', 'usegeneraldelta'))
 
 def gddeltaconfig(ui):
     """helper function to know if incoming delta should be optimised
     """
     # experimental config: format.generaldelta
     return ui.configbool('format', 'generaldelta')
 
 class simplekeyvaluefile(object):
     """A simple file with key=value lines
 
     Keys must be alphanumerics and start with a letter, values must not
     contain '\n' characters"""
     firstlinekey = '__firstline'
 
     def __init__(self, vfs, path, keys=None):
         self.vfs = vfs
         self.path = path
 
     def read(self, firstlinenonkeyval=False):
         """Read the contents of a simple key-value file
 
         'firstlinenonkeyval' indicates whether the first line of file should
         be treated as a key-value pair or reuturned fully under the
         __firstline key."""
         lines = self.vfs.readlines(self.path)
         d = {}
         if firstlinenonkeyval:
             if not lines:
                 e = _("empty simplekeyvalue file")
                 raise error.CorruptedState(e)
             # we don't want to include '\n' in the __firstline
             d[self.firstlinekey] = lines[0][:-1]
             del lines[0]
 
         try:
             # the 'if line.strip()' part prevents us from failing on empty
             # lines which only contain '\n' therefore are not skipped
             # by 'if line'
             updatedict = dict(line[:-1].split('=', 1) for line in lines
                                                       if line.strip())
             if self.firstlinekey in updatedict:
                 e = _("%r can't be used as a key")
                 raise error.CorruptedState(e % self.firstlinekey)
             d.update(updatedict)
         except ValueError as e:
             raise error.CorruptedState(str(e))
         return d
 
     def write(self, data, firstline=None):
         """Write key=>value mapping to a file
         data is a dict. Keys must be alphanumerical and start with a letter.
         Values must not contain newline characters.
 
         If 'firstline' is not None, it is written to file before
         everything else, as it is, not in a key=value form"""
         lines = []
         if firstline is not None:
             lines.append('%s\n' % firstline)
 
         for k, v in data.items():
             if k == self.firstlinekey:
                 e = "key name '%s' is reserved" % self.firstlinekey
                 raise error.ProgrammingError(e)
             if not k[0:1].isalpha():
                 e = "keys must start with a letter in a key-value file"
                 raise error.ProgrammingError(e)
             if not k.isalnum():
                 e = "invalid key name in a simple key-value file"
                 raise error.ProgrammingError(e)
             if '\n' in v:
                 e = "invalid value in a simple key-value file"
                 raise error.ProgrammingError(e)
             lines.append("%s=%s\n" % (k, v))
         with self.vfs(self.path, mode='wb', atomictemp=True) as fp:
             fp.write(''.join(lines))
 
 _reportobsoletedsource = [
     'debugobsolete',
     'pull',
     'push',
     'serve',
     'unbundle',
 ]
 
 _reportnewcssource = [
     'pull',
     'unbundle',
 ]
 
 def prefetchfiles(repo, revs, match):
     """Invokes the registered file prefetch functions, allowing extensions to
     ensure the corresponding files are available locally, before the command
     uses them."""
     if match:
         # The command itself will complain about files that don't exist, so
         # don't duplicate the message.
         match = matchmod.badmatch(match, lambda fn, msg: None)
     else:
         match = matchall(repo)
 
     fileprefetchhooks(repo, revs, match)
 
 # a list of (repo, revs, match) prefetch functions
 fileprefetchhooks = util.hooks()
 
 # A marker that tells the evolve extension to suppress its own reporting
 _reportstroubledchangesets = True
 
 def registersummarycallback(repo, otr, txnname=''):
     """register a callback to issue a summary after the transaction is closed
     """
     def txmatch(sources):
         return any(txnname.startswith(source) for source in sources)
 
     categories = []
 
     def reportsummary(func):
         """decorator for report callbacks."""
         # The repoview life cycle is shorter than the one of the actual
         # underlying repository. So the filtered object can die before the
         # weakref is used leading to troubles. We keep a reference to the
         # unfiltered object and restore the filtering when retrieving the
         # repository through the weakref.
         filtername = repo.filtername
         reporef = weakref.ref(repo.unfiltered())
         def wrapped(tr):
             repo = reporef()
             if filtername:
                 repo = repo.filtered(filtername)
             func(repo, tr)
         newcat = '%02i-txnreport' % len(categories)
         otr.addpostclose(newcat, wrapped)
         categories.append(newcat)
         return wrapped
 
+
+    @reportsummary
+    def reportchangegroup(repo, tr):
+        cgchangesets = tr.changes.get('changegroup-count-changesets', 0)
+        cgrevisions = tr.changes.get('changegroup-count-revisions', 0)
+        cgfiles = tr.changes.get('changegroup-count-files', 0)
+        cgheads = tr.changes.get('changegroup-count-heads', 0)
+        if cgchangesets or cgrevisions or cgfiles:
+            htext = ""
+            if cgheads:
+                htext = _(" (%+d heads)") % cgheads
+            msg = _("added %d changesets with %d changes to %d files%s\n")
+            repo.ui.status(msg % (cgchangesets, cgrevisions, cgfiles, htext))
+
     if txmatch(_reportobsoletedsource):
         @reportsummary
         def reportobsoleted(repo, tr):
             obsoleted = obsutil.getobsoleted(repo, tr)
             newmarkers = len(tr.changes.get('obsmarkers', ()))
             if newmarkers:
                 repo.ui.status(_('%i new obsolescence markers\n') % newmarkers)
             if obsoleted:
                 repo.ui.status(_('obsoleted %i changesets\n')
                                % len(obsoleted))
 
     if (obsolete.isenabled(repo, obsolete.createmarkersopt) and
         repo.ui.configbool('experimental', 'evolution.report-instabilities')):
         instabilitytypes = [
             ('orphan', 'orphan'),
             ('phase-divergent', 'phasedivergent'),
             ('content-divergent', 'contentdivergent'),
         ]
 
         def getinstabilitycounts(repo):
             filtered = repo.changelog.filteredrevs
             counts = {}
             for instability, revset in instabilitytypes:
                 counts[instability] = len(set(obsolete.getrevs(repo, revset)) -
                                           filtered)
             return counts
 
         oldinstabilitycounts = getinstabilitycounts(repo)
         @reportsummary
         def reportnewinstabilities(repo, tr):
             newinstabilitycounts = getinstabilitycounts(repo)
             for instability, revset in instabilitytypes:
                 delta = (newinstabilitycounts[instability] -
                          oldinstabilitycounts[instability])
                 msg = getinstabilitymessage(delta, instability)
                 if msg:
                     repo.ui.warn(msg)
 
     if txmatch(_reportnewcssource):
         @reportsummary
         def reportnewcs(repo, tr):
             """Report the range of new revisions pulled/unbundled."""
             origrepolen = tr.changes.get('origrepolen', len(repo))
             unfi = repo.unfiltered()
             if origrepolen >= len(unfi):
                 return
 
             # Compute the bounds of new visible revisions' range.
             revs = smartset.spanset(repo, start=origrepolen)
             if revs:
                 minrev, maxrev = repo[revs.min()], repo[revs.max()]
 
                 if minrev == maxrev:
                     revrange = minrev
                 else:
                     revrange = '%s:%s' % (minrev, maxrev)
                 draft = len(repo.revs('%ld and draft()', revs))
                 secret = len(repo.revs('%ld and secret()', revs))
                 if not (draft or secret):
                     msg = _('new changesets %s\n') % revrange
                 elif draft and secret:
                     msg = _('new changesets %s (%d drafts, %d secrets)\n')
                     msg %= (revrange, draft, secret)
                 elif draft:
                     msg = _('new changesets %s (%d drafts)\n')
                     msg %= (revrange, draft)
                 elif secret:
                     msg = _('new changesets %s (%d secrets)\n')
                     msg %= (revrange, secret)
                 else:
                     errormsg = 'entered unreachable condition'
                     raise error.ProgrammingError(errormsg)
                 repo.ui.status(msg)
 
             # search new changesets directly pulled as obsolete
             duplicates = tr.changes.get('revduplicates', ())
             obsadded = unfi.revs('(%d: + %ld) and obsolete()',
                                  origrepolen, duplicates)
             cl = repo.changelog
             extinctadded = [r for r in obsadded if r not in cl]
             if extinctadded:
                 # They are not just obsolete, but obsolete and invisible
                 # we call them "extinct" internally but the terms have not been
                 # exposed to users.
                 msg = '(%d other changesets obsolete on arrival)\n'
                 repo.ui.status(msg % len(extinctadded))
 
         @reportsummary
         def reportphasechanges(repo, tr):
             """Report statistics of phase changes for changesets pre-existing
             pull/unbundle.
             """
             origrepolen = tr.changes.get('origrepolen', len(repo))
             phasetracking = tr.changes.get('phases', {})
             if not phasetracking:
                 return
             published = [
                 rev for rev, (old, new) in phasetracking.iteritems()
                 if new == phases.public and rev < origrepolen
             ]
             if not published:
                 return
             repo.ui.status(_('%d local changesets published\n')
                            % len(published))
 
 def getinstabilitymessage(delta, instability):
     """function to return the message to show warning about new instabilities
 
     exists as a separate function so that extension can wrap to show more
     information like how to fix instabilities"""
     if delta > 0:
         return _('%i new %s changesets\n') % (delta, instability)
 
 def nodesummaries(repo, nodes, maxnumnodes=4):
     if len(nodes) <= maxnumnodes or repo.ui.verbose:
         return ' '.join(short(h) for h in nodes)
     first = ' '.join(short(h) for h in nodes[:maxnumnodes])
     return _("%s and %d others") % (first, len(nodes) - maxnumnodes)
 
 def enforcesinglehead(repo, tr, desc):
     """check that no named branch has multiple heads"""
     if desc in ('strip', 'repair'):
         # skip the logic during strip
         return
     visible = repo.filtered('visible')
     # possible improvement: we could restrict the check to affected branch
     for name, heads in visible.branchmap().iteritems():
         if len(heads) > 1:
             msg = _('rejecting multiple heads on branch "%s"')
             msg %= name
             hint = _('%d heads: %s')
             hint %= (len(heads), nodesummaries(repo, heads))
             raise error.Abort(msg, hint=hint)
 
 def wrapconvertsink(sink):
     """Allow extensions to wrap the sink returned by convcmd.convertsink()
     before it is used, whether or not the convert extension was formally loaded.
     """
     return sink
 
 def unhidehashlikerevs(repo, specs, hiddentype):
     """parse the user specs and unhide changesets whose hash or revision number
     is passed.
 
     hiddentype can be: 1) 'warn': warn while unhiding changesets
                        2) 'nowarn': don't warn while unhiding changesets
 
     returns a repo object with the required changesets unhidden
     """
     if not repo.filtername or not repo.ui.configbool('experimental',
                                                      'directaccess'):
         return repo
 
     if repo.filtername not in ('visible', 'visible-hidden'):
         return repo
 
     symbols = set()
     for spec in specs:
         try:
             tree = revsetlang.parse(spec)
         except error.ParseError: # will be reported by scmutil.revrange()
             continue
 
         symbols.update(revsetlang.gethashlikesymbols(tree))
 
     if not symbols:
         return repo
 
     revs = _getrevsfromsymbols(repo, symbols)
 
     if not revs:
         return repo
 
     if hiddentype == 'warn':
         unfi = repo.unfiltered()
         revstr = ", ".join([pycompat.bytestr(unfi[l]) for l in revs])
         repo.ui.warn(_("warning: accessing hidden changesets for write "
                        "operation: %s\n") % revstr)
 
     # we have to use new filtername to separate branch/tags cache until we can
     # disbale these cache when revisions are dynamically pinned.
     return repo.filtered('visible-hidden', revs)
 
 def _getrevsfromsymbols(repo, symbols):
     """parse the list of symbols and returns a set of revision numbers of hidden
     changesets present in symbols"""
     revs = set()
     unfi = repo.unfiltered()
     unficl = unfi.changelog
     cl = repo.changelog
     tiprev = len(unficl)
     allowrevnums = repo.ui.configbool('experimental', 'directaccess.revnums')
     for s in symbols:
         try:
             n = int(s)
             if n <= tiprev:
                 if not allowrevnums:
                     continue
                 else:
                     if n not in cl:
                         revs.add(n)
                     continue
         except ValueError:
             pass
 
         try:
             s = resolvehexnodeidprefix(unfi, s)
         except (error.LookupError, error.WdirUnsupported):
             s = None
 
         if s is not None:
             rev = unficl.rev(s)
             if rev not in cl:
                 revs.add(rev)
 
     return revs
 
 def bookmarkrevs(repo, mark):
     """
     Select revisions reachable by a given bookmark
     """
     return repo.revs("ancestors(bookmark(%s)) - "
                      "ancestors(head() and not bookmark(%s)) - "
                      "ancestors(bookmark() and not bookmark(%s))",
                      mark, mark, mark)
 
 def computechangesetfilesadded(ctx):
     """return the list of files added in a changeset
     """
     added = []
     for f in ctx.files():
         if not any(f in p for p in ctx.parents()):
             added.append(f)
     return added
 
 def computechangesetfilesremoved(ctx):
     """return the list of files removed in a changeset
     """
     removed = []
     for f in ctx.files():
         if f not in ctx:
             removed.append(f)
     return removed

tests/test-acl.t

@@ -1,2411 +1,2394 b''
   > do_push()
   > {
   >     user=$1
   >     shift
   >     echo "Pushing as user $user"
   >     echo 'hgrc = """'
   >     sed -n '/\[[ha]/,$p' b/.hg/hgrc | grep -v fakegroups.py
   >     echo '"""'
   >     if test -f acl.config; then
   >         echo 'acl.config = """'
   >         cat acl.config
   >         echo '"""'
   >     fi
   >     # On AIX /etc/profile sets LOGNAME read-only. So
   >     #  LOGNAME=$user hg --cws a --debug push ../b
   >     # fails with "This variable is read only."
   >     # Use env to work around this.
   >     env LOGNAME=$user hg --cwd a --debug push ../b $*
   >     hg --cwd b rollback
   >     hg --cwd b --quiet tip
   >     echo
   > }
 
   > cat > posixgetuser.py <<'EOF'
   > import getpass
   > from mercurial import pycompat
   > from mercurial.utils import procutil
   > def posixgetuser():
   >     return pycompat.fsencode(getpass.getuser())
   > if not pycompat.isposix:
   >     procutil.getuser = posixgetuser  # forcibly trust $LOGNAME
   > EOF
 
   > init_config()
   > {
   >     cat > fakegroups.py <<EOF
   > from hgext import acl
   > def fakegetusers(ui, group):
   >     try:
   >         return acl._getusersorig(ui, group)
   >     except BaseException:
   >         return [b"fred", b"betty"]
   > acl._getusersorig = acl._getusers
   > acl._getusers = fakegetusers
   > EOF
   >     rm -f acl.config
   >     cat > $config <<EOF
   > [hooks]
   > pretxnchangegroup.acl = python:hgext.acl.hook
   > prepushkey.acl = python:hgext.acl.hook
   > [acl]
   > sources = push
   > [extensions]
   > f=`pwd`/fakegroups.py
   > posixgetuser=$TESTTMP/posixgetuser.py
   > EOF
   > }
 
   $ hg init a
   $ cd a
   $ mkdir foo foo/Bar quux
   $ echo 'in foo' > foo/file.txt
   $ echo 'in foo/Bar' > foo/Bar/file.txt
   $ echo 'in quux' > quux/file.py
   $ hg add -q
   $ hg ci -m 'add files' -d '1000000 0'
   $ echo >> foo/file.txt
   $ hg ci -m 'change foo/file' -d '1000001 0'
   $ echo >> foo/Bar/file.txt
   $ hg ci -m 'change foo/Bar/file' -d '1000002 0'
   $ echo >> quux/file.py
   $ hg ci -m 'change quux/file' -d '1000003 0'
   $ hg tip --quiet
   3:911600dab2ae
 
   $ cd ..
   $ hg clone -r 0 a b
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 3 changes to 3 files
   new changesets 6675d58eff77
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ config=b/.hg/hgrc
   $ cat >> "$config" <<EOF
   > [extensions]
   > posixgetuser=$TESTTMP/posixgetuser.py
   > EOF
 
 Extension disabled for lack of a hook
 
   $ do_push fred
   Pushing as user fred
   hgrc = """
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   adding manifests
   adding file changes
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 3 changesets with 3 changes to 3 files
   bundle2-input-part: total payload size 1553
   bundle2-input-part: "phase-heads" supported
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 4 parts total
   updating the branch cache
+  added 3 changesets with 3 changes to 3 files
   bundle2-output-bundle: "HG20", 1 parts total
   bundle2-output-part: "reply:changegroup" (advisory) (params: 0 advisory) empty payload
   bundle2-input-bundle: no-transaction
   bundle2-input-part: "reply:changegroup" (advisory) (params: 0 advisory) supported
   bundle2-input-bundle: 0 parts total
   listing keys for "phases"
   repository tip rolled back to revision 0 (undo push)
   0:6675d58eff77
   
 
   $ echo '[hooks]' >> $config
   $ echo 'pretxnchangegroup.acl = python:hgext.acl.hook' >> $config
   $ echo 'prepushkey.acl = python:hgext.acl.hook' >> $config
 
 Extension disabled for lack of acl.sources
 
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   adding manifests
   adding file changes
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: changes have source "push" - skipping
   bundle2-input-part: total payload size 1553
   bundle2-input-part: "phase-heads" supported
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 4 parts total
   updating the branch cache
+  added 3 changesets with 3 changes to 3 files
   bundle2-output-bundle: "HG20", 1 parts total
   bundle2-output-part: "reply:changegroup" (advisory) (params: 0 advisory) empty payload
   bundle2-input-bundle: no-transaction
   bundle2-input-part: "reply:changegroup" (advisory) (params: 0 advisory) supported
   bundle2-input-bundle: 0 parts total
   listing keys for "phases"
   repository tip rolled back to revision 0 (undo push)
   0:6675d58eff77
   
 
 No [acl.allow]/[acl.deny]
 
   $ echo '[acl]' >> $config
   $ echo 'sources = push' >> $config
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   adding manifests
   adding file changes
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   bundle2-input-part: total payload size 1553
   bundle2-input-part: "phase-heads" supported
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 4 parts total
   updating the branch cache
+  added 3 changesets with 3 changes to 3 files
   bundle2-output-bundle: "HG20", 1 parts total
   bundle2-output-part: "reply:changegroup" (advisory) (params: 0 advisory) empty payload
   bundle2-input-bundle: no-transaction
   bundle2-input-part: "reply:changegroup" (advisory) (params: 0 advisory) supported
   bundle2-input-bundle: 0 parts total
   listing keys for "phases"
   repository tip rolled back to revision 0 (undo push)
   0:6675d58eff77
   
 
 Empty [acl.allow]
 
   $ echo '[acl.allow]' >> $config
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   adding manifests
   adding file changes
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 0 entries for user fred
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "fred" not allowed on "foo/file.txt" (changeset "ef1ea85a6374")
   bundle2-input-part: total payload size 1553
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 4 parts total
   transaction abort!
   rollback completed
   abort: acl: user "fred" not allowed on "foo/file.txt" (changeset "ef1ea85a6374")
   no rollback information available
   0:6675d58eff77
   
 
 fred is allowed inside foo/
 
   $ echo 'foo/** = fred' >> $config
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   adding manifests
   adding file changes
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user fred
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "fred" not allowed on "quux/file.py" (changeset "911600dab2ae")
   bundle2-input-part: total payload size 1553
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 4 parts total
   transaction abort!
   rollback completed
   abort: acl: user "fred" not allowed on "quux/file.py" (changeset "911600dab2ae")
   no rollback information available
   0:6675d58eff77
   
 
 Empty [acl.deny]
 
   $ echo '[acl.deny]' >> $config
   $ do_push barney
   Pushing as user barney
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   adding manifests
   adding file changes
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "barney"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 0 entries for user barney
   acl: acl.deny enabled, 0 entries for user barney
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "barney" not allowed on "foo/file.txt" (changeset "ef1ea85a6374")
   bundle2-input-part: total payload size 1553
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 4 parts total
   transaction abort!
   rollback completed
   abort: acl: user "barney" not allowed on "foo/file.txt" (changeset "ef1ea85a6374")
   no rollback information available
   0:6675d58eff77
   
 
 fred is allowed inside foo/, but not foo/bar/ (case matters)
 
   $ echo 'foo/bar/** = fred' >> $config
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   foo/bar/** = fred
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   adding manifests
   adding file changes
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user fred
   acl: acl.deny enabled, 1 entries for user fred
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "fred" not allowed on "quux/file.py" (changeset "911600dab2ae")
   bundle2-input-part: total payload size 1553
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 4 parts total
   transaction abort!
   rollback completed
   abort: acl: user "fred" not allowed on "quux/file.py" (changeset "911600dab2ae")
   no rollback information available
   0:6675d58eff77
   
 
 fred is allowed inside foo/, but not foo/Bar/
 
   $ echo 'foo/Bar/** = fred' >> $config
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   foo/bar/** = fred
   foo/Bar/** = fred
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   adding manifests
   adding file changes
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user fred
   acl: acl.deny enabled, 2 entries for user fred
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "fred" denied on "foo/Bar/file.txt" (changeset "f9cafe1212c8")
   bundle2-input-part: total payload size 1553
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 4 parts total
   transaction abort!
   rollback completed
   abort: acl: user "fred" denied on "foo/Bar/file.txt" (changeset "f9cafe1212c8")
   no rollback information available
   0:6675d58eff77
   
 
   $ echo 'barney is not mentioned => not allowed anywhere'
   barney is not mentioned => not allowed anywhere
   $ do_push barney
   Pushing as user barney
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   foo/bar/** = fred
   foo/Bar/** = fred
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   adding manifests
   adding file changes
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "barney"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 0 entries for user barney
   acl: acl.deny enabled, 0 entries for user barney
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "barney" not allowed on "foo/file.txt" (changeset "ef1ea85a6374")
   bundle2-input-part: total payload size 1553
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 4 parts total
   transaction abort!
   rollback completed
   abort: acl: user "barney" not allowed on "foo/file.txt" (changeset "ef1ea85a6374")
   no rollback information available
   0:6675d58eff77
   
 
 fred is not blocked from moving bookmarks
 
   $ hg -R a book -q moving-bookmark -r 1
   $ hg -R b book -q moving-bookmark -r 0
   $ cp $config normalconfig
   $ do_push fred -r 1
   Pushing as user fred
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   foo/bar/** = fred
   foo/Bar/** = fred
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   1 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   bundle2-output-bundle: "HG20", 7 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:bookmarks" 37 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-output-part: "bookmarks" 37 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:bookmarks" supported
   bundle2-input-part: total payload size 37
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   adding manifests
   adding file changes
   adding foo/file.txt revisions
-  added 1 changesets with 1 changes to 1 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user fred
   acl: acl.deny enabled, 2 entries for user fred
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   bundle2-input-part: total payload size 520
   bundle2-input-part: "phase-heads" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "bookmarks" supported
   bundle2-input-part: total payload size 37
   calling hook prepushkey.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.bookmarks not enabled
   acl: acl.deny.bookmarks not enabled
   acl: bookmark access granted: "ef1ea85a6374b77d6da9dcda9541f498f2d17df7" on bookmark "moving-bookmark"
   bundle2-input-bundle: 6 parts total
   updating the branch cache
+  added 1 changesets with 1 changes to 1 files
   bundle2-output-bundle: "HG20", 1 parts total
   bundle2-output-part: "reply:changegroup" (advisory) (params: 0 advisory) empty payload
   bundle2-input-bundle: no-transaction
   bundle2-input-part: "reply:changegroup" (advisory) (params: 0 advisory) supported
   bundle2-input-bundle: 0 parts total
   updating bookmark moving-bookmark
   listing keys for "phases"
   repository tip rolled back to revision 0 (undo push)
   0:6675d58eff77
   
 
 fred is not allowed to move bookmarks
 
   $ echo '[acl.deny.bookmarks]' >> $config
   $ echo '* = fred' >> $config
   $ do_push fred -r 1
   Pushing as user fred
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   foo/bar/** = fred
   foo/Bar/** = fred
   [acl.deny.bookmarks]
   * = fred
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   1 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   bundle2-output-bundle: "HG20", 7 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:bookmarks" 37 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-output-part: "bookmarks" 37 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:bookmarks" supported
   bundle2-input-part: total payload size 37
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   adding manifests
   adding file changes
   adding foo/file.txt revisions
-  added 1 changesets with 1 changes to 1 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user fred
   acl: acl.deny enabled, 2 entries for user fred
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   bundle2-input-part: total payload size 520
   bundle2-input-part: "phase-heads" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "bookmarks" supported
   bundle2-input-part: total payload size 37
   calling hook prepushkey.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.bookmarks not enabled
   acl: acl.deny.bookmarks enabled, 1 entries for user fred
   error: prepushkey.acl hook failed: acl: user "fred" denied on bookmark "moving-bookmark" (changeset "ef1ea85a6374b77d6da9dcda9541f498f2d17df7")
   bundle2-input-bundle: 6 parts total
   transaction abort!
   rollback completed
   abort: acl: user "fred" denied on bookmark "moving-bookmark" (changeset "ef1ea85a6374b77d6da9dcda9541f498f2d17df7")
   no rollback information available
   0:6675d58eff77
   
 
 cleanup bookmark stuff
 
   $ hg book -R a -d moving-bookmark
   $ hg book -R b -d moving-bookmark
   $ cp normalconfig $config
 
 barney is allowed everywhere
 
   $ echo '[acl.allow]' >> $config
   $ echo '** = barney' >> $config
   $ do_push barney
   Pushing as user barney
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   foo/bar/** = fred
   foo/Bar/** = fred
   [acl.allow]
   ** = barney
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   adding manifests
   adding file changes
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "barney"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user barney
   acl: acl.deny enabled, 0 entries for user barney
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   bundle2-input-part: total payload size 1553
   bundle2-input-part: "phase-heads" supported
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 4 parts total
   updating the branch cache
+  added 3 changesets with 3 changes to 3 files
   bundle2-output-bundle: "HG20", 1 parts total
   bundle2-output-part: "reply:changegroup" (advisory) (params: 0 advisory) empty payload
   bundle2-input-bundle: no-transaction
   bundle2-input-part: "reply:changegroup" (advisory) (params: 0 advisory) supported
   bundle2-input-bundle: 0 parts total
   listing keys for "phases"
   repository tip rolled back to revision 0 (undo push)
   0:6675d58eff77
   
 
 wilma can change files with a .txt extension
 
   $ echo '**/*.txt = wilma' >> $config
   $ do_push wilma
   Pushing as user wilma
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   foo/bar/** = fred
   foo/Bar/** = fred
   [acl.allow]
   ** = barney
   **/*.txt = wilma
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   adding manifests
   adding file changes
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "wilma"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user wilma
   acl: acl.deny enabled, 0 entries for user wilma
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "wilma" not allowed on "quux/file.py" (changeset "911600dab2ae")
   bundle2-input-part: total payload size 1553
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 4 parts total
   transaction abort!
   rollback completed
   abort: acl: user "wilma" not allowed on "quux/file.py" (changeset "911600dab2ae")
   no rollback information available
   0:6675d58eff77
   
 
 file specified by acl.config does not exist
 
   $ echo '[acl]' >> $config
   $ echo 'config = ../acl.config' >> $config
   $ do_push barney
   Pushing as user barney
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   foo/bar/** = fred
   foo/Bar/** = fred
   [acl.allow]
   ** = barney
   **/*.txt = wilma
   [acl]
   config = ../acl.config
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   adding manifests
   adding file changes
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "barney"
   error: pretxnchangegroup.acl hook raised an exception: [Errno *] * (glob)
   bundle2-input-part: total payload size 1553
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 4 parts total
   transaction abort!
   rollback completed
   abort: $ENOENT$: '../acl.config'
   no rollback information available
   0:6675d58eff77
   
 
 betty is allowed inside foo/ by a acl.config file
 
   $ echo '[acl.allow]' >> acl.config
   $ echo 'foo/** = betty' >> acl.config
   $ do_push betty
   Pushing as user betty
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   foo/bar/** = fred
   foo/Bar/** = fred
   [acl.allow]
   ** = barney
   **/*.txt = wilma
   [acl]
   config = ../acl.config
   """
   acl.config = """
   [acl.allow]
   foo/** = betty
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   adding manifests
   adding file changes
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "betty"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user betty
   acl: acl.deny enabled, 0 entries for user betty
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "betty" not allowed on "quux/file.py" (changeset "911600dab2ae")
   bundle2-input-part: total payload size 1553
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 4 parts total
   transaction abort!
   rollback completed
   abort: acl: user "betty" not allowed on "quux/file.py" (changeset "911600dab2ae")
   no rollback information available
   0:6675d58eff77
   
 
 acl.config can set only [acl.allow]/[acl.deny]
 
   $ echo '[hooks]' >> acl.config
   $ echo 'changegroup.acl = false' >> acl.config
   $ do_push barney
   Pushing as user barney
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [acl.allow]
   foo/** = fred
   [acl.deny]
   foo/bar/** = fred
   foo/Bar/** = fred
   [acl.allow]
   ** = barney
   **/*.txt = wilma
   [acl]
   config = ../acl.config
   """
   acl.config = """
   [acl.allow]
   foo/** = betty
   [hooks]
   changegroup.acl = false
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   adding manifests
   adding file changes
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "barney"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user barney
   acl: acl.deny enabled, 0 entries for user barney
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   bundle2-input-part: total payload size 1553
   bundle2-input-part: "phase-heads" supported
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 4 parts total
   updating the branch cache
+  added 3 changesets with 3 changes to 3 files
   bundle2-output-bundle: "HG20", 1 parts total
   bundle2-output-part: "reply:changegroup" (advisory) (params: 0 advisory) empty payload
   bundle2-input-bundle: no-transaction
   bundle2-input-part: "reply:changegroup" (advisory) (params: 0 advisory) supported
   bundle2-input-bundle: 0 parts total
   listing keys for "phases"
   repository tip rolled back to revision 0 (undo push)
   0:6675d58eff77
   
 
 asterisk
 
   $ init_config
 
 asterisk test
 
   $ echo '[acl.allow]' >> $config
   $ echo "** = fred" >> $config
 
 fred is always allowed
 
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [extensions]
   posixgetuser=$TESTTMP/posixgetuser.py
   [acl.allow]
   ** = fred
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   adding manifests
   adding file changes
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user fred
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   bundle2-input-part: total payload size 1553
   bundle2-input-part: "phase-heads" supported
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 4 parts total
   updating the branch cache
+  added 3 changesets with 3 changes to 3 files
   bundle2-output-bundle: "HG20", 1 parts total
   bundle2-output-part: "reply:changegroup" (advisory) (params: 0 advisory) empty payload
   bundle2-input-bundle: no-transaction
   bundle2-input-part: "reply:changegroup" (advisory) (params: 0 advisory) supported
   bundle2-input-bundle: 0 parts total
   listing keys for "phases"
   repository tip rolled back to revision 0 (undo push)
   0:6675d58eff77
   
 
   $ echo '[acl.deny]' >> $config
   $ echo "foo/Bar/** = *" >> $config
 
 no one is allowed inside foo/Bar/
 
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [extensions]
   posixgetuser=$TESTTMP/posixgetuser.py
   [acl.allow]
   ** = fred
   [acl.deny]
   foo/Bar/** = *
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   adding manifests
   adding file changes
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow enabled, 1 entries for user fred
   acl: acl.deny enabled, 1 entries for user fred
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "fred" denied on "foo/Bar/file.txt" (changeset "f9cafe1212c8")
   bundle2-input-part: total payload size 1553
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 4 parts total
   transaction abort!
   rollback completed
   abort: acl: user "fred" denied on "foo/Bar/file.txt" (changeset "f9cafe1212c8")
   no rollback information available
   0:6675d58eff77
   
 
 Groups
 
   $ init_config
 
 OS-level groups
 
   $ echo '[acl.allow]' >> $config
   $ echo "** = @group1" >> $config
 
 @group1 is always allowed
 
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [extensions]
   posixgetuser=$TESTTMP/posixgetuser.py
   [acl.allow]
   ** = @group1
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   adding manifests
   adding file changes
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: "group1" not defined in [acl.groups]
   acl: acl.allow enabled, 1 entries for user fred
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   bundle2-input-part: total payload size 1553
   bundle2-input-part: "phase-heads" supported
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 4 parts total
   updating the branch cache
+  added 3 changesets with 3 changes to 3 files
   bundle2-output-bundle: "HG20", 1 parts total
   bundle2-output-part: "reply:changegroup" (advisory) (params: 0 advisory) empty payload
   bundle2-input-bundle: no-transaction
   bundle2-input-part: "reply:changegroup" (advisory) (params: 0 advisory) supported
   bundle2-input-bundle: 0 parts total
   listing keys for "phases"
   repository tip rolled back to revision 0 (undo push)
   0:6675d58eff77
   
 
   $ echo '[acl.deny]' >> $config
   $ echo "foo/Bar/** = @group1" >> $config
 
 @group is allowed inside anything but foo/Bar/
 
   $ do_push fred
   Pushing as user fred
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [extensions]
   posixgetuser=$TESTTMP/posixgetuser.py
   [acl.allow]
   ** = @group1
   [acl.deny]
   foo/Bar/** = @group1
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   3 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 24 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 24
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   adding manifests
   adding file changes
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 3 changesets with 3 changes to 3 files
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "fred"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: "group1" not defined in [acl.groups]
   acl: acl.allow enabled, 1 entries for user fred
   acl: "group1" not defined in [acl.groups]
   acl: acl.deny enabled, 1 entries for user fred
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   error: pretxnchangegroup.acl hook failed: acl: user "fred" denied on "foo/Bar/file.txt" (changeset "f9cafe1212c8")
   bundle2-input-part: total payload size 1553
   bundle2-input-part: total payload size 24
   bundle2-input-bundle: 4 parts total
   transaction abort!
   rollback completed
   abort: acl: user "fred" denied on "foo/Bar/file.txt" (changeset "f9cafe1212c8")
   no rollback information available
   0:6675d58eff77
   
 
 Invalid group
 
 Disable the fakegroups trick to get real failures
 
   $ grep -v fakegroups $config > config.tmp
   $ mv config.tmp $config
   $ echo '[acl.allow]' >> $config
   $ echo "** = @unlikelytoexist" >> $config
   $ do_push fred 2>&1 | grep unlikelytoexist
   ** = @unlikelytoexist
   acl: "unlikelytoexist" not defined in [acl.groups]
   error: pretxnchangegroup.acl hook failed: group 'unlikelytoexist' is undefined
   abort: group 'unlikelytoexist' is undefined
 
 
 Branch acl tests setup
 
   $ init_config
   $ cd b
   $ hg up
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch foobar
   marked working directory as branch foobar
   (branches are permanent and global, did you want a bookmark?)
   $ hg commit -m 'create foobar'
   $ echo 'foo contents' > abc.txt
   $ hg add abc.txt
   $ hg commit -m 'foobar contents'
   $ cd ..
   $ hg --cwd a pull ../b
   pulling from ../b
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 1 changes to 1 files (+1 heads)
   new changesets 81fbf4469322:fb35475503ef
   (run 'hg heads' to see heads)
 
 Create additional changeset on foobar branch
 
   $ cd a
   $ hg up -C foobar
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 'foo contents2' > abc.txt
   $ hg commit -m 'foobar contents2'
   $ cd ..
 
 
 No branch acls specified
 
   $ do_push astro
   Pushing as user astro
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [extensions]
   posixgetuser=$TESTTMP/posixgetuser.py
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   4 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   e8fc755d4d8217ee5b0c2bb41558c40d43b92c01
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 48 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 48 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 48
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   add changeset e8fc755d4d82
   adding manifests
   adding file changes
   adding abc.txt revisions
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 4 changesets with 4 changes to 4 files (+1 heads)
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "astro"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches not enabled
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   acl: branch access granted: "e8fc755d4d82" on branch "foobar"
   acl: path access granted: "e8fc755d4d82"
   bundle2-input-part: total payload size 2068
   bundle2-input-part: "phase-heads" supported
   bundle2-input-part: total payload size 48
   bundle2-input-bundle: 4 parts total
   updating the branch cache
+  added 4 changesets with 4 changes to 4 files (+1 heads)
   bundle2-output-bundle: "HG20", 1 parts total
   bundle2-output-part: "reply:changegroup" (advisory) (params: 0 advisory) empty payload
   bundle2-input-bundle: no-transaction
   bundle2-input-part: "reply:changegroup" (advisory) (params: 0 advisory) supported
   bundle2-input-bundle: 0 parts total
   listing keys for "phases"
   repository tip rolled back to revision 2 (undo push)
   2:fb35475503ef
   
 
 Branch acl deny test
 
   $ echo "[acl.deny.branches]" >> $config
   $ echo "foobar = *" >> $config
   $ do_push astro
   Pushing as user astro
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [extensions]
   posixgetuser=$TESTTMP/posixgetuser.py
   [acl.deny.branches]
   foobar = *
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   4 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   e8fc755d4d8217ee5b0c2bb41558c40d43b92c01
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 48 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 48 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 48
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   add changeset e8fc755d4d82
   adding manifests
   adding file changes
   adding abc.txt revisions
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 4 changesets with 4 changes to 4 files (+1 heads)
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "astro"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches enabled, 1 entries for user astro
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   error: pretxnchangegroup.acl hook failed: acl: user "astro" denied on branch "foobar" (changeset "e8fc755d4d82")
   bundle2-input-part: total payload size 2068
   bundle2-input-part: total payload size 48
   bundle2-input-bundle: 4 parts total
   transaction abort!
   rollback completed
   abort: acl: user "astro" denied on branch "foobar" (changeset "e8fc755d4d82")
   no rollback information available
   2:fb35475503ef
   
 
 Branch acl empty allow test
 
   $ init_config
   $ echo "[acl.allow.branches]" >> $config
   $ do_push astro
   Pushing as user astro
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [extensions]
   posixgetuser=$TESTTMP/posixgetuser.py
   [acl.allow.branches]
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   4 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   e8fc755d4d8217ee5b0c2bb41558c40d43b92c01
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 48 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 48 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 48
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   add changeset e8fc755d4d82
   adding manifests
   adding file changes
   adding abc.txt revisions
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 4 changesets with 4 changes to 4 files (+1 heads)
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "astro"
   acl: acl.allow.branches enabled, 0 entries for user astro
   acl: acl.deny.branches not enabled
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   error: pretxnchangegroup.acl hook failed: acl: user "astro" not allowed on branch "default" (changeset "ef1ea85a6374")
   bundle2-input-part: total payload size 2068
   bundle2-input-part: total payload size 48
   bundle2-input-bundle: 4 parts total
   transaction abort!
   rollback completed
   abort: acl: user "astro" not allowed on branch "default" (changeset "ef1ea85a6374")
   no rollback information available
   2:fb35475503ef
   
 
 Branch acl allow other
 
   $ init_config
   $ echo "[acl.allow.branches]" >> $config
   $ echo "* = george" >> $config
   $ do_push astro
   Pushing as user astro
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [extensions]
   posixgetuser=$TESTTMP/posixgetuser.py
   [acl.allow.branches]
   * = george
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   4 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   e8fc755d4d8217ee5b0c2bb41558c40d43b92c01
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 48 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 48 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 48
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   add changeset e8fc755d4d82
   adding manifests
   adding file changes
   adding abc.txt revisions
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 4 changesets with 4 changes to 4 files (+1 heads)
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "astro"
   acl: acl.allow.branches enabled, 0 entries for user astro
   acl: acl.deny.branches not enabled
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   error: pretxnchangegroup.acl hook failed: acl: user "astro" not allowed on branch "default" (changeset "ef1ea85a6374")
   bundle2-input-part: total payload size 2068
   bundle2-input-part: total payload size 48
   bundle2-input-bundle: 4 parts total
   transaction abort!
   rollback completed
   abort: acl: user "astro" not allowed on branch "default" (changeset "ef1ea85a6374")
   no rollback information available
   2:fb35475503ef
   
   $ do_push george
   Pushing as user george
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [extensions]
   posixgetuser=$TESTTMP/posixgetuser.py
   [acl.allow.branches]
   * = george
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   4 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   e8fc755d4d8217ee5b0c2bb41558c40d43b92c01
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 48 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 48 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 48
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   add changeset e8fc755d4d82
   adding manifests
   adding file changes
   adding abc.txt revisions
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 4 changesets with 4 changes to 4 files (+1 heads)
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "george"
   acl: acl.allow.branches enabled, 1 entries for user george
   acl: acl.deny.branches not enabled
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   acl: branch access granted: "e8fc755d4d82" on branch "foobar"
   acl: path access granted: "e8fc755d4d82"
   bundle2-input-part: total payload size 2068
   bundle2-input-part: "phase-heads" supported
   bundle2-input-part: total payload size 48
   bundle2-input-bundle: 4 parts total
   updating the branch cache
+  added 4 changesets with 4 changes to 4 files (+1 heads)
   bundle2-output-bundle: "HG20", 1 parts total
   bundle2-output-part: "reply:changegroup" (advisory) (params: 0 advisory) empty payload
   bundle2-input-bundle: no-transaction
   bundle2-input-part: "reply:changegroup" (advisory) (params: 0 advisory) supported
   bundle2-input-bundle: 0 parts total
   listing keys for "phases"
   repository tip rolled back to revision 2 (undo push)
   2:fb35475503ef
   
 
 Branch acl conflicting allow
 asterisk ends up applying to all branches and allowing george to
 push foobar into the remote
 
   $ init_config
   $ echo "[acl.allow.branches]" >> $config
   $ echo "foobar = astro" >> $config
   $ echo "* = george" >> $config
   $ do_push george
   Pushing as user george
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [extensions]
   posixgetuser=$TESTTMP/posixgetuser.py
   [acl.allow.branches]
   foobar = astro
   * = george
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   4 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   e8fc755d4d8217ee5b0c2bb41558c40d43b92c01
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 48 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 48 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 48
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   add changeset e8fc755d4d82
   adding manifests
   adding file changes
   adding abc.txt revisions
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 4 changesets with 4 changes to 4 files (+1 heads)
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "george"
   acl: acl.allow.branches enabled, 1 entries for user george
   acl: acl.deny.branches not enabled
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   acl: branch access granted: "e8fc755d4d82" on branch "foobar"
   acl: path access granted: "e8fc755d4d82"
   bundle2-input-part: total payload size 2068
   bundle2-input-part: "phase-heads" supported
   bundle2-input-part: total payload size 48
   bundle2-input-bundle: 4 parts total
   updating the branch cache
+  added 4 changesets with 4 changes to 4 files (+1 heads)
   bundle2-output-bundle: "HG20", 1 parts total
   bundle2-output-part: "reply:changegroup" (advisory) (params: 0 advisory) empty payload
   bundle2-input-bundle: no-transaction
   bundle2-input-part: "reply:changegroup" (advisory) (params: 0 advisory) supported
   bundle2-input-bundle: 0 parts total
   listing keys for "phases"
   repository tip rolled back to revision 2 (undo push)
   2:fb35475503ef
   
 Branch acl conflicting deny
 
   $ init_config
   $ echo "[acl.deny.branches]" >> $config
   $ echo "foobar = astro" >> $config
   $ echo "default = astro" >> $config
   $ echo "* = george" >> $config
   $ do_push george
   Pushing as user george
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [extensions]
   posixgetuser=$TESTTMP/posixgetuser.py
   [acl.deny.branches]
   foobar = astro
   default = astro
   * = george
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   4 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   e8fc755d4d8217ee5b0c2bb41558c40d43b92c01
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 48 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 48 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 48
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   add changeset e8fc755d4d82
   adding manifests
   adding file changes
   adding abc.txt revisions
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 4 changesets with 4 changes to 4 files (+1 heads)
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "george"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches enabled, 1 entries for user george
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   error: pretxnchangegroup.acl hook failed: acl: user "george" denied on branch "default" (changeset "ef1ea85a6374")
   bundle2-input-part: total payload size 2068
   bundle2-input-part: total payload size 48
   bundle2-input-bundle: 4 parts total
   transaction abort!
   rollback completed
   abort: acl: user "george" denied on branch "default" (changeset "ef1ea85a6374")
   no rollback information available
   2:fb35475503ef
   
 User 'astro' must not be denied
 
   $ init_config
   $ echo "[acl.deny.branches]" >> $config
   $ echo "default = !astro" >> $config
   $ do_push astro
   Pushing as user astro
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [extensions]
   posixgetuser=$TESTTMP/posixgetuser.py
   [acl.deny.branches]
   default = !astro
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   4 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   e8fc755d4d8217ee5b0c2bb41558c40d43b92c01
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 48 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 48 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 48
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   add changeset e8fc755d4d82
   adding manifests
   adding file changes
   adding abc.txt revisions
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 4 changesets with 4 changes to 4 files (+1 heads)
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "astro"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches enabled, 0 entries for user astro
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   acl: branch access granted: "ef1ea85a6374" on branch "default"
   acl: path access granted: "ef1ea85a6374"
   acl: branch access granted: "f9cafe1212c8" on branch "default"
   acl: path access granted: "f9cafe1212c8"
   acl: branch access granted: "911600dab2ae" on branch "default"
   acl: path access granted: "911600dab2ae"
   acl: branch access granted: "e8fc755d4d82" on branch "foobar"
   acl: path access granted: "e8fc755d4d82"
   bundle2-input-part: total payload size 2068
   bundle2-input-part: "phase-heads" supported
   bundle2-input-part: total payload size 48
   bundle2-input-bundle: 4 parts total
   updating the branch cache
+  added 4 changesets with 4 changes to 4 files (+1 heads)
   bundle2-output-bundle: "HG20", 1 parts total
   bundle2-output-part: "reply:changegroup" (advisory) (params: 0 advisory) empty payload
   bundle2-input-bundle: no-transaction
   bundle2-input-part: "reply:changegroup" (advisory) (params: 0 advisory) supported
   bundle2-input-bundle: 0 parts total
   listing keys for "phases"
   repository tip rolled back to revision 2 (undo push)
   2:fb35475503ef
   
 
 Non-astro users must be denied
 
   $ do_push george
   Pushing as user george
   hgrc = """
   [hooks]
   pretxnchangegroup.acl = python:hgext.acl.hook
   prepushkey.acl = python:hgext.acl.hook
   [acl]
   sources = push
   [extensions]
   posixgetuser=$TESTTMP/posixgetuser.py
   [acl.deny.branches]
   default = !astro
   """
   pushing to ../b
   query 1; heads
   searching for changes
   all remote heads known locally
   listing keys for "phases"
   checking for updated bookmarks
   listing keys for "bookmarks"
   listing keys for "bookmarks"
   4 changesets found
   list of changesets:
   ef1ea85a6374b77d6da9dcda9541f498f2d17df7
   f9cafe1212c8c6fa1120d14a556e18cc44ff8bdd
   911600dab2ae7a9baff75958b84fe606851ce955
   e8fc755d4d8217ee5b0c2bb41558c40d43b92c01
   bundle2-output-bundle: "HG20", 5 parts total
   bundle2-output-part: "replycaps" 205 bytes payload
   bundle2-output-part: "check:phases" 48 bytes payload
   bundle2-output-part: "check:heads" streamed payload
   bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
   bundle2-output-part: "phase-heads" 48 bytes payload
   bundle2-input-bundle: with-transaction
   bundle2-input-part: "replycaps" supported
   bundle2-input-part: total payload size 205
   bundle2-input-part: "check:phases" supported
   bundle2-input-part: total payload size 48
   bundle2-input-part: "check:heads" supported
   bundle2-input-part: total payload size 20
   bundle2-input-part: "changegroup" (params: 1 mandatory) supported
   adding changesets
   add changeset ef1ea85a6374
   add changeset f9cafe1212c8
   add changeset 911600dab2ae
   add changeset e8fc755d4d82
   adding manifests
   adding file changes
   adding abc.txt revisions
   adding foo/Bar/file.txt revisions
   adding foo/file.txt revisions
   adding quux/file.py revisions
-  added 4 changesets with 4 changes to 4 files (+1 heads)
   calling hook pretxnchangegroup.acl: hgext.acl.hook
   acl: checking access for user "george"
   acl: acl.allow.branches not enabled
   acl: acl.deny.branches enabled, 1 entries for user george
   acl: acl.allow not enabled
   acl: acl.deny not enabled
   error: pretxnchangegroup.acl hook failed: acl: user "george" denied on branch "default" (changeset "ef1ea85a6374")
   bundle2-input-part: total payload size 2068
   bundle2-input-part: total payload size 48
   bundle2-input-bundle: 4 parts total
   transaction abort!
   rollback completed
   abort: acl: user "george" denied on branch "default" (changeset "ef1ea85a6374")
   no rollback information available
   2:fb35475503ef
   
 

tests/test-bookflow.t

@@ -1,292 +1,292 b''
 initialize
   $ make_changes() {
   >     d=`pwd`
   >     [ ! -z $1 ] && cd $1
   >     echo "test `basename \`pwd\``" >> test
   >     hg commit -Am"${2:-test}"
   >     r=$?
   >     cd $d
   >     return $r
   > }
   $ ls -1a
   .
   ..
   $ hg init a
   $ cd a
   $ echo 'test' > test; hg commit -Am'test'
   adding test
 
 clone to b
 
   $ mkdir ../b
   $ cd ../b
   $ hg clone ../a .
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo "[extensions]" >> .hg/hgrc
   $ echo "bookflow=" >> .hg/hgrc
   $ hg branch X
   abort: creating named branches is disabled and you should use bookmarks
   (see 'hg help bookflow')
   [255]
   $ hg bookmark X
   $ hg bookmarks
   * X                         0:* (glob)
   $ hg bookmark X
   abort: bookmark X already exists, to move use the --rev option
   [255]
   $ make_changes
   $ hg push ../a -q
 
   $ hg bookmarks
    \* X                         1:* (glob)
 
 change a
   $ cd ../a
   $ hg up
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 'test' >> test; hg commit -Am'test'
 
 
 pull in b
   $ cd ../b
   $ hg pull -u
   pulling from $TESTTMP/a
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets * (glob)
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (leaving bookmark X)
   $ hg status
   $ hg bookmarks
      X                         1:* (glob)
 
 check protection of @ bookmark
   $ hg bookmark @
   $ hg bookmarks
    \* @                         2:* (glob)
      X                         1:* (glob)
   $ make_changes
   abort: cannot commit, bookmark @ is protected
   [255]
 
   $ hg status
   M test
   $ hg bookmarks
    \* @                         2:* (glob)
      X                         1:* (glob)
 
   $ hg --config bookflow.protect= commit  -Am"Updated test"
 
   $ hg bookmarks
    \* @                         3:* (glob)
      X                         1:* (glob)
 
 check requirement for an active bookmark
   $ hg bookmark -i
   $ hg bookmarks
      @                         3:* (glob)
      X                         1:* (glob)
   $ make_changes
   abort: cannot commit without an active bookmark
   [255]
   $ hg revert test
   $ rm test.orig
   $ hg status
 
 
 make the bookmark move by updating it on a, and then pulling
 # add a commit to a
   $ cd ../a
   $ hg bookmark X
   $ hg bookmarks
    \* X                         2:* (glob)
   $ make_changes
   $ hg bookmarks
    * X                         3:81af7977fdb9
 
 # go back to b, and check out X
   $ cd ../b
   $ hg up X
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark X)
   $ hg bookmarks
      @                         3:* (glob)
    \* X                         1:* (glob)
 
 # pull, this should move the bookmark forward, because it was changed remotely
   $ hg pull -u | grep "updating to active bookmark X"
   updating to active bookmark X
 
   $ hg bookmarks
      @                         3:* (glob)
    * X                         4:81af7977fdb9
 
 the bookmark should not move if it diverged from remote
   $ hg -R ../a status
   $ hg -R ../b status
   $ make_changes ../a
   $ make_changes ../b
   $ hg -R ../a status
   $ hg -R ../b status
   $ hg -R ../a bookmarks
    * X                         4:238292f60a57
   $ hg -R ../b bookmarks
      @                         3:* (glob)
    * X                         5:096f7e86892d
   $ cd ../b
   $ # make sure we cannot push after bookmarks diverged
   $ hg push -B X | grep abort
   abort: push creates new remote head * with bookmark 'X'! (glob)
   (pull and merge or see 'hg help push' for details about pushing new heads)
   [1]
   $ hg pull -u | grep divergent
   divergent bookmark X stored as X@default
   1 other divergent bookmarks for "X"
   $ hg bookmarks
      @                         3:* (glob)
    * X                         5:096f7e86892d
      X@default                 6:238292f60a57
   $ hg id -in
   096f7e86892d 5
   $ make_changes
   $ hg status
   $ hg bookmarks
      @                         3:* (glob)
    * X                         7:227f941aeb07
      X@default                 6:238292f60a57
 
 now merge with the remote bookmark
   $ hg merge X@default --tool :local -q
   $ hg status
   M test
   $ hg commit -m"Merged with X@default"
   $ hg bookmarks
      @                         3:* (glob)
    * X                         8:26fed9bb3219
   $ hg push -B X | grep bookmark
   pushing to $TESTTMP/a (?)
   updating bookmark X
   $ cd ../a
   $ hg up -q
   $ hg bookmarks
    * X                         7:26fed9bb3219
 
 test hg pull when there is more than one descendant
   $ cd ../a
   $ hg bookmark Z
   $ hg bookmark Y
   $ make_changes . YY
   $ hg up Z -q
   $ make_changes . ZZ
   created new head
   $ hg bookmarks
      X                         7:26fed9bb3219
      Y                         8:131e663dbd2a
    * Z                         9:b74a4149df25
   $ hg log -r 'p1(Y)' -r 'p1(Z)' -T '{rev}\n' # prove that Y and Z share the same parent
   7
   $ hg log -r 'Y%Z' -T '{rev}\n'  # revs in Y but not in Z
   8
   $ hg log -r 'Z%Y' -T '{rev}\n'  # revs in Z but not in Y
   9
   $ cd ../b
   $ hg pull -uq
   $ hg id
   b74a4149df25 tip Z
   $ hg bookmarks | grep \*  # no active bookmark
   [1]
 
 
 test shelving
   $ cd ../a
   $ echo anotherfile > anotherfile # this change should not conflict
   $ hg add anotherfile
   $ hg commit -m"Change in a"
   $ cd ../b
   $ hg up Z | grep Z
   (activating bookmark Z)
   $ hg book | grep \* # make sure active bookmark
    \* Z                         10:* (glob)
   $ echo "test b" >> test
   $ hg diff --stat
    test |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   $ hg shelve
   shelved as Z
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg pull -uq
   $ hg unshelve
   unshelving change 'Z'
   rebasing shelved changes
   $ hg diff --stat
    test |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
 
 
 make the bookmark move by updating it on a, and then pulling with a local change
 # add a commit to a
   $ cd ../a
   $ hg up -C X |fgrep  "activating bookmark X"
   (activating bookmark X)
 # go back to b, and check out X
   $ cd ../b
   $ hg up -C X |fgrep  "activating bookmark X"
   (activating bookmark X)
 # update and push from a
   $ make_changes ../a
   created new head
   $ echo "more" >> test
   $ hg pull -u 2>&1 | fgrep -v TESTTMP| fgrep -v "searching for changes" | fgrep -v adding
   pulling from $TESTTMP/a
+  updating bookmark X
   added 1 changesets with 0 changes to 0 files (+1 heads)
-  updating bookmark X
   new changesets * (glob)
   updating to active bookmark X
   merging test
   warning: conflicts while merging test! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges
   $ hg update -Cq
   $ rm test.orig
 
 make sure that commits aren't possible if working directory is not pointing to active bookmark
   $ hg -R ../a status
   $ hg -R ../b status
   $ hg -R ../a id -i
   36a6e592ec06
   $ hg -R ../a book | grep X
    \* X                         \d+:36a6e592ec06 (re)
   $ hg -R ../b id -i
   36a6e592ec06
   $ hg -R ../b book | grep X
    \* X                         \d+:36a6e592ec06 (re)
   $ make_changes ../a
   $ hg -R ../a book | grep X
    \* X                         \d+:f73a71c992b8 (re)
   $ cd ../b
   $ hg pull  2>&1 | grep -v add | grep -v pulling | grep -v searching | grep -v changeset
   updating bookmark X
   (run 'hg update' to get a working copy)
   working directory out of sync with active bookmark, run 'hg up X'
   $ hg id -i # we're still on the old commit
   36a6e592ec06
   $ hg book | grep X # while the bookmark moved
    \* X                         \d+:f73a71c992b8 (re)
   $ make_changes
   abort: cannot commit, working directory out of sync with active bookmark
   (run 'hg up X')
   [255]
   $ hg up -Cq -r .  # cleanup local changes
   $ hg status
   $ hg id -i # we're still on the old commit
   36a6e592ec06
   $ hg up X -q
   $ hg id -i # now we're on X
   f73a71c992b8
   $ hg book | grep X
    \* X                         \d+:f73a71c992b8 (re)
 

tests/test-bookmarks-pushpull.t

@@ -1,1355 +1,1355 b''
 #testcases b2-pushkey b2-binary
 
 #if b2-pushkey
   $ cat << EOF >> $HGRCPATH
   > [devel]
   > legacy.exchange=bookmarks
   > EOF
 #endif
 
 #require serve
 
   $ cat << EOF >> $HGRCPATH
   > [ui]
   > logtemplate={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
-  added 1 changesets with 1 changes to 1 files
   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" 222 bytes payload
   bundle2-output: part 0: "REPLYCAPS"
   bundle2-output: header chunk size: 16
   bundle2-output: payload chunk size: 222
   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: 222
   bundle2-input: payload chunk size: 0
   bundle2-input-part: total payload size 222
   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: 3 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: 0 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" 222 bytes payload
   bundle2-output: part 0: "REPLYCAPS"
   bundle2-output: header chunk size: 16
   bundle2-output: payload chunk size: 222
   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: 222
   bundle2-input: payload chunk size: 0
   bundle2-input-part: total payload size 222
   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: 3 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
 
 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!
   [255]
 
 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
-  added 1 changesets with 1 changes to 1 files (+1 heads)
   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
-  updating bookmark Y
   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
-  updating bookmark Y
   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
-  updating bookmark Y
   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)
   [255]
   $ 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)
   [255]
   $ 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)
   [255]
   $ 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
   [255]
 
 #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]
 
 #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]
 
 #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]
 #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]

tests/test-bookmarks.t

@@ -1,1236 +1,1236 b''
 
   $ hg init repo
   $ cd repo
 
   $ 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"
 
 no bookmarks
 
   $ hg bookmarks
   no bookmarks set
 
   $ hg bookmarks -Tjson
   [
   ]
 
 bookmark rev -1
 
   $ hg bookmark X --config "$TESTHOOK"
   test-hook-bookmark: X:   -> 0000000000000000000000000000000000000000
 
 list bookmarks
 
   $ hg bookmarks
    * X                         -1:000000000000
 
 list bookmarks with color
 
   $ hg --config extensions.color= --config color.mode=ansi \
   >    bookmarks --color=always
   \x1b[0;32m * \x1b[0m\x1b[0;32mX\x1b[0m\x1b[0;32m                         -1:000000000000\x1b[0m (esc)
 
   $ echo a > a
   $ hg add a
   $ hg commit -m 0 --config "$TESTHOOK"
   test-hook-bookmark: X:  0000000000000000000000000000000000000000 -> f7b1eb17ad24730a1651fccd46c43826d1bbc2ac
 
 bookmark X moved to rev 0
 
   $ hg bookmarks
    * X                         0:f7b1eb17ad24
 
 look up bookmark
 
   $ hg log -r X
   changeset:   0:f7b1eb17ad24
   bookmark:    X
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0
   
 
 second bookmark for rev 0, command should work even with ui.strict on
 
   $ hg --config ui.strict=1 bookmark X2 --config "$TESTHOOK"
   test-hook-bookmark: X2:   -> f7b1eb17ad24730a1651fccd46c43826d1bbc2ac
 
 bookmark rev -1 again
 
   $ hg bookmark -r null Y
 
 list bookmarks
 
   $ hg bookmarks
      X                         0:f7b1eb17ad24
    * X2                        0:f7b1eb17ad24
      Y                         -1:000000000000
   $ hg bookmarks -l
      X                         0:f7b1eb17ad24
    * X2                        0:f7b1eb17ad24
      Y                         -1:000000000000
   $ hg bookmarks -l X Y
      X                         0:f7b1eb17ad24
      Y                         -1:000000000000
   $ hg bookmarks -l .
    * X2                        0:f7b1eb17ad24
   $ hg bookmarks -l X A Y
   abort: bookmark 'A' does not exist
   [255]
   $ hg bookmarks -l -r0
   abort: --rev is incompatible with --list
   [255]
   $ hg bookmarks -l --inactive
   abort: --inactive is incompatible with --list
   [255]
 
   $ hg log -T '{bookmarks % "{rev} {bookmark}\n"}'
   0 X
   0 X2
 
   $ echo b > b
   $ hg add b
   $ hg commit -m 1 --config "$TESTHOOK"
   test-hook-bookmark: X2:  f7b1eb17ad24730a1651fccd46c43826d1bbc2ac -> 925d80f479bb026b0fb3deb27503780b13f74123
 
   $ hg bookmarks -T '{rev}:{node|shortest} {bookmark} {desc|firstline}\n'
   0:f7b1 X 0
   1:925d X2 1
   -1:0000 Y 
 
   $ hg bookmarks -Tjson
   [
    {
     "active": false,
     "bookmark": "X",
     "node": "f7b1eb17ad24730a1651fccd46c43826d1bbc2ac",
     "rev": 0
    },
    {
     "active": true,
     "bookmark": "X2",
     "node": "925d80f479bb026b0fb3deb27503780b13f74123",
     "rev": 1
    },
    {
     "active": false,
     "bookmark": "Y",
     "node": "0000000000000000000000000000000000000000",
     "rev": -1
    }
   ]
 
 bookmarks revset
 
   $ hg log -r 'bookmark()'
   changeset:   0:f7b1eb17ad24
   bookmark:    X
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0
   
   changeset:   1:925d80f479bb
   bookmark:    X2
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1
   
   $ hg log -r 'bookmark(Y)'
   $ hg log -r 'bookmark(X2)'
   changeset:   1:925d80f479bb
   bookmark:    X2
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1
   
   $ hg log -r 'bookmark("re:X")'
   changeset:   0:f7b1eb17ad24
   bookmark:    X
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0
   
   changeset:   1:925d80f479bb
   bookmark:    X2
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1
   
   $ hg log -r 'bookmark("literal:X")'
   changeset:   0:f7b1eb17ad24
   bookmark:    X
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0
   
 
 "." is expanded to the active bookmark:
 
   $ hg log -r 'bookmark(.)'
   changeset:   1:925d80f479bb
   bookmark:    X2
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1
   
 
 but "literal:." is not since "." seems not a literal bookmark:
 
   $ hg log -r 'bookmark("literal:.")'
   abort: bookmark '.' does not exist!
   [255]
 
 "." should fail if there's no active bookmark:
 
   $ hg bookmark --inactive
   $ hg log -r 'bookmark(.)'
   abort: no active bookmark!
   [255]
   $ hg log -r 'present(bookmark(.))'
 
   $ hg log -r 'bookmark(unknown)'
   abort: bookmark 'unknown' does not exist!
   [255]
   $ hg log -r 'bookmark("literal:unknown")'
   abort: bookmark 'unknown' does not exist!
   [255]
   $ hg log -r 'bookmark("re:unknown")'
   $ hg log -r 'present(bookmark("literal:unknown"))'
   $ hg log -r 'present(bookmark("re:unknown"))'
 
   $ hg help revsets | grep 'bookmark('
       "bookmark([name])"
 
 reactivate "X2"
 
   $ hg update X2
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark X2)
 
 bookmarks X and X2 moved to rev 1, Y at rev -1
 
   $ hg bookmarks
      X                         0:f7b1eb17ad24
    * X2                        1:925d80f479bb
      Y                         -1:000000000000
 
 bookmark rev 0 again
 
   $ hg bookmark -r 0 Z
 
   $ hg update X
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (activating bookmark X)
   $ echo c > c
   $ hg add c
   $ hg commit -m 2
   created new head
 
 bookmarks X moved to rev 2, Y at rev -1, Z at rev 0
 
   $ hg bookmarks
    * X                         2:db815d6d32e6
      X2                        1:925d80f479bb
      Y                         -1:000000000000
      Z                         0:f7b1eb17ad24
 
 rename nonexistent bookmark
 
   $ hg bookmark -m A B
   abort: bookmark 'A' does not exist
   [255]
 
 rename to existent bookmark
 
   $ hg bookmark -m X Y
   abort: bookmark 'Y' already exists (use -f to force)
   [255]
 
 force rename to existent bookmark
 
   $ hg bookmark -f -m X Y
 
 rename bookmark using .
 
   $ hg book rename-me
   $ hg book -m . renamed --config "$TESTHOOK"
   test-hook-bookmark: rename-me:  db815d6d32e69058eadefc8cffbad37675707975 -> 
   test-hook-bookmark: renamed:   -> db815d6d32e69058eadefc8cffbad37675707975
   $ hg bookmark
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         0:f7b1eb17ad24
    * renamed                   2:db815d6d32e6
   $ hg up -q Y
   $ hg book -d renamed --config "$TESTHOOK"
   test-hook-bookmark: renamed:  db815d6d32e69058eadefc8cffbad37675707975 -> 
 
 rename bookmark using . with no active bookmark
 
   $ hg book rename-me
   $ hg book -i rename-me
   $ hg book -m . renamed
   abort: no active bookmark!
   [255]
   $ hg up -q Y
   $ hg book -d rename-me
 
 delete bookmark using .
 
   $ hg book delete-me
   $ hg book -d .
   $ hg bookmark
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         0:f7b1eb17ad24
   $ hg up -q Y
 
 delete bookmark using . with no active bookmark
 
   $ hg book delete-me
   $ hg book -i delete-me
   $ hg book -d .
   abort: no active bookmark!
   [255]
   $ hg up -q Y
   $ hg book -d delete-me
 
 list bookmarks
 
   $ hg bookmark
      X2                        1:925d80f479bb
    * Y                         2:db815d6d32e6
      Z                         0:f7b1eb17ad24
 
 bookmarks from a revset
   $ hg bookmark -r '.^1' REVSET
   $ hg bookmark -r ':tip' TIP
   $ hg up -q TIP
   $ hg bookmarks
      REVSET                    0:f7b1eb17ad24
    * TIP                       2:db815d6d32e6
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         0:f7b1eb17ad24
 
   $ hg bookmark -d REVSET
   $ hg bookmark -d TIP
 
 rename without new name or multiple names
 
   $ hg bookmark -m Y
   abort: new bookmark name required
   [255]
   $ hg bookmark -m Y Y2 Y3
   abort: only one new bookmark name allowed
   [255]
 
 delete without name
 
   $ hg bookmark -d
   abort: bookmark name required
   [255]
 
 delete nonexistent bookmark
 
   $ hg bookmark -d A
   abort: bookmark 'A' does not exist
   [255]
 
 delete with --inactive
 
   $ hg bookmark -d --inactive Y
   abort: --inactive is incompatible with --delete
   [255]
 
 bookmark name with spaces should be stripped
 
   $ hg bookmark ' x  y '
 
 list bookmarks
 
   $ hg bookmarks
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         0:f7b1eb17ad24
    * x  y                      2:db815d6d32e6
   $ hg log -T '{bookmarks % "{rev} {bookmark}\n"}'
   2 Y
   2 x  y
   1 X2
   0 Z
 
 look up stripped bookmark name
 
   $ hg log -r '"x  y"'
   changeset:   2:db815d6d32e6
   bookmark:    Y
   bookmark:    x  y
   tag:         tip
   parent:      0:f7b1eb17ad24
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
 
 reject bookmark name with newline
 
   $ hg bookmark '
   > '
   abort: bookmark names cannot consist entirely of whitespace
   [255]
 
   $ hg bookmark -m Z '
   > '
   abort: bookmark names cannot consist entirely of whitespace
   [255]
 
 bookmark with reserved name
 
   $ hg bookmark tip
   abort: the name 'tip' is reserved
   [255]
 
   $ hg bookmark .
   abort: the name '.' is reserved
   [255]
 
   $ hg bookmark null
   abort: the name 'null' is reserved
   [255]
 
 
 bookmark with existing name
 
   $ hg bookmark X2
   abort: bookmark 'X2' already exists (use -f to force)
   [255]
 
   $ hg bookmark -m Y Z
   abort: bookmark 'Z' already exists (use -f to force)
   [255]
 
 bookmark with name of branch
 
   $ hg bookmark default
   abort: a bookmark cannot have the name of an existing branch
   [255]
 
   $ hg bookmark -m Y default
   abort: a bookmark cannot have the name of an existing branch
   [255]
 
 bookmark with integer name
 
   $ hg bookmark 10
   abort: cannot use an integer as a name
   [255]
 
 bookmark with a name that matches a node id
   $ hg bookmark 925d80f479bb db815d6d32e6 --config "$TESTHOOK"
   bookmark 925d80f479bb matches a changeset hash
   (did you leave a -r out of an 'hg bookmark' command?)
   bookmark db815d6d32e6 matches a changeset hash
   (did you leave a -r out of an 'hg bookmark' command?)
   test-hook-bookmark: 925d80f479bb:   -> db815d6d32e69058eadefc8cffbad37675707975
   test-hook-bookmark: db815d6d32e6:   -> db815d6d32e69058eadefc8cffbad37675707975
   $ hg bookmark -d 925d80f479bb
   $ hg bookmark -d db815d6d32e6
 
   $ cd ..
 
 bookmark with a name that matches an ambiguous node id
 
   $ hg init ambiguous
   $ cd ambiguous
   $ echo 0 > a
   $ hg ci -qAm 0
   $ for i in 1057 2857 4025; do
   >   hg up -q 0
   >   echo $i > a
   >   hg ci -qm $i
   > done
   $ hg up -q null
   $ hg log -r0: -T '{rev}:{node}\n'
   0:b4e73ffab476aa0ee32ed81ca51e07169844bc6a
   1:c56256a09cd28e5764f32e8e2810d0f01e2e357a
   2:c5623987d205cd6d9d8389bfc40fff9dbb670b48
   3:c562ddd9c94164376c20b86b0b4991636a3bf84f
 
   $ hg bookmark -r0 c562
   $ hg bookmarks
      c562                      0:b4e73ffab476
 
   $ cd ..
 
 incompatible options
 
   $ cd repo
 
   $ hg bookmark -m Y -d Z
   abort: --delete and --rename are incompatible
   [255]
 
   $ hg bookmark -r 1 -d Z
   abort: --rev is incompatible with --delete
   [255]
 
   $ hg bookmark -r 1 -m Z Y
   abort: --rev is incompatible with --rename
   [255]
 
 force bookmark with existing name
 
   $ hg bookmark -f X2 --config "$TESTHOOK"
   test-hook-bookmark: X2:  925d80f479bb026b0fb3deb27503780b13f74123 -> db815d6d32e69058eadefc8cffbad37675707975
 
 force bookmark back to where it was, should deactivate it
 
   $ hg bookmark -fr1 X2
   $ hg bookmarks
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         0:f7b1eb17ad24
      x  y                      2:db815d6d32e6
 
 forward bookmark to descendant without --force
 
   $ hg bookmark Z
   moving bookmark 'Z' forward from f7b1eb17ad24
 
 list bookmarks
 
   $ hg bookmark
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
    * Z                         2:db815d6d32e6
      x  y                      2:db815d6d32e6
   $ hg log -T '{bookmarks % "{rev} {bookmark}\n"}'
   2 Y
   2 Z
   2 x  y
   1 X2
 
 revision but no bookmark name
 
   $ hg bookmark -r .
   abort: bookmark name required
   [255]
 
 bookmark name with whitespace only
 
   $ hg bookmark ' '
   abort: bookmark names cannot consist entirely of whitespace
   [255]
 
   $ hg bookmark -m Y ' '
   abort: bookmark names cannot consist entirely of whitespace
   [255]
 
 invalid bookmark
 
   $ hg bookmark 'foo:bar'
   abort: ':' cannot be used in a name
   [255]
 
   $ hg bookmark 'foo
   > bar'
   abort: '\n' cannot be used in a name
   [255]
 
 the bookmark extension should be ignored now that it is part of core
 
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "bookmarks=" >> $HGRCPATH
   $ hg bookmarks
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
    * Z                         2:db815d6d32e6
      x  y                      2:db815d6d32e6
 
 test summary
 
   $ hg summary
   parent: 2:db815d6d32e6 tip
    2
   branch: default
   bookmarks: *Z Y x  y
   commit: (clean)
   update: 1 new changesets, 2 branch heads (merge)
   phases: 3 draft
 
 test id
 
   $ hg id
   db815d6d32e6 tip Y/Z/x  y
 
 test rollback
 
   $ echo foo > f1
   $ hg bookmark tmp-rollback
   $ hg ci -Amr
   adding f1
   $ hg bookmarks
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         2:db815d6d32e6
    * tmp-rollback              3:2bf5cfec5864
      x  y                      2:db815d6d32e6
   $ hg rollback
   repository tip rolled back to revision 2 (undo commit)
   working directory now based on revision 2
   $ hg bookmarks
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         2:db815d6d32e6
    * tmp-rollback              2:db815d6d32e6
      x  y                      2:db815d6d32e6
   $ hg bookmark -f Z -r 1
   $ hg rollback
   repository tip rolled back to revision 2 (undo bookmark)
   $ hg bookmarks
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         2:db815d6d32e6
    * tmp-rollback              2:db815d6d32e6
      x  y                      2:db815d6d32e6
   $ hg bookmark -d tmp-rollback
 
 activate bookmark on working dir parent without --force
 
   $ hg bookmark --inactive Z
   $ hg bookmark Z
 
 test clone
 
   $ hg bookmark -r 2 -i @
   $ hg bookmark -r 2 -i a@
   $ hg bookmarks
      @                         2:db815d6d32e6
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
    * Z                         2:db815d6d32e6
      a@                        2:db815d6d32e6
      x  y                      2:db815d6d32e6
   $ hg clone . cloned-bookmarks
   updating to bookmark @
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R cloned-bookmarks bookmarks
    * @                         2:db815d6d32e6
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         2:db815d6d32e6
      a@                        2:db815d6d32e6
      x  y                      2:db815d6d32e6
 
 test clone with pull protocol
 
   $ hg clone --pull . cloned-bookmarks-pull
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 3 files (+1 heads)
   new changesets f7b1eb17ad24:db815d6d32e6
   updating to bookmark @
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R cloned-bookmarks-pull bookmarks
    * @                         2:db815d6d32e6
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         2:db815d6d32e6
      a@                        2:db815d6d32e6
      x  y                      2:db815d6d32e6
 
 delete multiple bookmarks at once
 
   $ hg bookmark -d @ a@
 
 test clone with a bookmark named "default" (issue3677)
 
   $ hg bookmark -r 1 -f -i default
   $ hg clone . cloned-bookmark-default
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R cloned-bookmark-default bookmarks
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         2:db815d6d32e6
      default                   1:925d80f479bb
      x  y                      2:db815d6d32e6
   $ hg -R cloned-bookmark-default parents -q
   2:db815d6d32e6
   $ hg bookmark -d default
 
 test clone with a specific revision
 
   $ hg clone -r 925d80 . cloned-bookmarks-rev
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   new changesets f7b1eb17ad24:925d80f479bb
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R cloned-bookmarks-rev bookmarks
      X2                        1:925d80f479bb
 
 test clone with update to a bookmark
 
   $ hg clone -u Z . ../cloned-bookmarks-update
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R ../cloned-bookmarks-update bookmarks
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
    * Z                         2:db815d6d32e6
      x  y                      2:db815d6d32e6
 
 create bundle with two heads
 
   $ hg clone . tobundle
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo x > tobundle/x
   $ hg -R tobundle add tobundle/x
   $ hg -R tobundle commit -m'x'
   $ hg -R tobundle update -r -2
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo y > tobundle/y
   $ hg -R tobundle branch test
   marked working directory as branch test
   (branches are permanent and global, did you want a bookmark?)
   $ hg -R tobundle add tobundle/y
   $ hg -R tobundle commit -m'y'
   $ hg -R tobundle bundle tobundle.hg
   searching for changes
   2 changesets found
   $ hg unbundle tobundle.hg
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files (+1 heads)
   new changesets 125c9a1d6df6:9ba5f110a0b3 (2 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
 update to active bookmark if it's not the parent
 
 (it is known issue that fsmonitor can't handle nested repositories. In
 this test scenario, cloned-bookmark-default and tobundle exist in the
 working directory of current repository)
 
   $ hg summary
   parent: 2:db815d6d32e6 
    2
   branch: default
   bookmarks: *Z Y x  y
   commit: 1 added, 1 unknown (new branch head) (no-fsmonitor !)
   commit: 1 added, * unknown (new branch head) (glob) (fsmonitor !)
   update: 2 new changesets (update)
   phases: 5 draft
   $ hg update
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updating bookmark Z
   $ hg bookmarks
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
    * Z                         3:125c9a1d6df6
      x  y                      2:db815d6d32e6
 
 pull --update works the same as pull && update
 
   $ hg bookmark -r3 Y
   moving bookmark 'Y' forward from db815d6d32e6
   $ cp -R ../cloned-bookmarks-update ../cloned-bookmarks-manual-update
   $ cp -R ../cloned-bookmarks-update ../cloned-bookmarks-manual-update-with-divergence
 
 (manual version)
 
   $ hg -R ../cloned-bookmarks-manual-update update Y
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark Y)
   $ hg -R ../cloned-bookmarks-manual-update pull .
   pulling from .
   searching for changes
   adding changesets
   adding manifests
   adding file changes
-  added 2 changesets with 2 changes to 2 files (+1 heads)
   updating bookmark Y
   updating bookmark Z
+  added 2 changesets with 2 changes to 2 files (+1 heads)
   new changesets 125c9a1d6df6:9ba5f110a0b3
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
 (# tests strange but with --date crashing when bookmark have to move)
 
   $ hg -R ../cloned-bookmarks-manual-update update -d 1986
   abort: revision matching date not found
   [255]
   $ hg -R ../cloned-bookmarks-manual-update update
   updating to active bookmark Y
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 (all in one version)
 
   $ hg -R ../cloned-bookmarks-update update Y
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark Y)
   $ hg -R ../cloned-bookmarks-update pull --update .
   pulling from .
   searching for changes
   adding changesets
   adding manifests
   adding file changes
-  added 2 changesets with 2 changes to 2 files (+1 heads)
   updating bookmark Y
   updating bookmark Z
+  added 2 changesets with 2 changes to 2 files (+1 heads)
   new changesets 125c9a1d6df6:9ba5f110a0b3
   updating to active bookmark Y
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 We warn about divergent during bare update to the active bookmark
 
   $ hg -R ../cloned-bookmarks-manual-update-with-divergence update Y
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark Y)
   $ hg -R ../cloned-bookmarks-manual-update-with-divergence bookmarks -r X2 Y@1
   $ hg -R ../cloned-bookmarks-manual-update-with-divergence bookmarks
      X2                        1:925d80f479bb
    * Y                         2:db815d6d32e6
      Y@1                       1:925d80f479bb
      Z                         2:db815d6d32e6
      x  y                      2:db815d6d32e6
   $ hg -R ../cloned-bookmarks-manual-update-with-divergence pull
   pulling from $TESTTMP/repo
   searching for changes
   adding changesets
   adding manifests
   adding file changes
-  added 2 changesets with 2 changes to 2 files (+1 heads)
   updating bookmark Y
   updating bookmark Z
+  added 2 changesets with 2 changes to 2 files (+1 heads)
   new changesets 125c9a1d6df6:9ba5f110a0b3
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg -R ../cloned-bookmarks-manual-update-with-divergence update
   updating to active bookmark Y
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   1 other divergent bookmarks for "Y"
 
 test wrongly formated bookmark
 
   $ echo '' >> .hg/bookmarks
   $ hg bookmarks
      X2                        1:925d80f479bb
      Y                         3:125c9a1d6df6
    * Z                         3:125c9a1d6df6
      x  y                      2:db815d6d32e6
   $ echo "Ican'thasformatedlines" >> .hg/bookmarks
   $ hg bookmarks
   malformed line in .hg/bookmarks: "Ican'thasformatedlines"
      X2                        1:925d80f479bb
      Y                         3:125c9a1d6df6
    * Z                         3:125c9a1d6df6
      x  y                      2:db815d6d32e6
 
 test missing revisions
 
   $ echo "925d80f479b925d80f479bc925d80f479bccabab z" > .hg/bookmarks
   $ hg book
   no bookmarks set
 
 test stripping a non-checked-out but bookmarked revision
 
   $ hg log --graph
   o  changeset:   4:9ba5f110a0b3
   |  branch:      test
   |  tag:         tip
   |  parent:      2:db815d6d32e6
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     y
   |
   | @  changeset:   3:125c9a1d6df6
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     x
   |
   o  changeset:   2:db815d6d32e6
   |  parent:      0:f7b1eb17ad24
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     2
   |
   | o  changeset:   1:925d80f479bb
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     1
   |
   o  changeset:   0:f7b1eb17ad24
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     0
   
   $ hg book should-end-on-two
   $ hg co --clean 4
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (leaving bookmark should-end-on-two)
   $ hg book four
   $ hg --config extensions.mq= strip 3
   saved backup bundle to * (glob)
 should-end-on-two should end up pointing to revision 2, as that's the
 tipmost surviving ancestor of the stripped revision.
   $ hg log --graph
   @  changeset:   3:9ba5f110a0b3
   |  branch:      test
   |  bookmark:    four
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     y
   |
   o  changeset:   2:db815d6d32e6
   |  bookmark:    should-end-on-two
   |  parent:      0:f7b1eb17ad24
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     2
   |
   | o  changeset:   1:925d80f479bb
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     1
   |
   o  changeset:   0:f7b1eb17ad24
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     0
   
 
 no-op update doesn't deactivate bookmarks
 
 (it is known issue that fsmonitor can't handle nested repositories. In
 this test scenario, cloned-bookmark-default and tobundle exist in the
 working directory of current repository)
 
   $ hg bookmarks
    * four                      3:9ba5f110a0b3
      should-end-on-two         2:db815d6d32e6
   $ hg up four
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg up
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg sum
   parent: 3:9ba5f110a0b3 tip
    y
   branch: test
   bookmarks: *four
   commit: 2 unknown (clean) (no-fsmonitor !)
   commit: * unknown (clean) (glob) (fsmonitor !)
   update: (current)
   phases: 4 draft
 
 test clearing divergent bookmarks of linear ancestors
 
   $ hg bookmark Z -r 0
   $ hg bookmark Z@1 -r 1
   $ hg bookmark Z@2 -r 2
   $ hg bookmark Z@3 -r 3
   $ hg book
      Z                         0:f7b1eb17ad24
      Z@1                       1:925d80f479bb
      Z@2                       2:db815d6d32e6
      Z@3                       3:9ba5f110a0b3
    * four                      3:9ba5f110a0b3
      should-end-on-two         2:db815d6d32e6
   $ hg bookmark Z
   moving bookmark 'Z' forward from f7b1eb17ad24
   $ hg book
    * Z                         3:9ba5f110a0b3
      Z@1                       1:925d80f479bb
      four                      3:9ba5f110a0b3
      should-end-on-two         2:db815d6d32e6
 
 test clearing only a single divergent bookmark across branches
 
   $ hg book foo -r 1
   $ hg book foo@1 -r 0
   $ hg book foo@2 -r 2
   $ hg book foo@3 -r 3
   $ hg book foo -r foo@3
   $ hg book
    * Z                         3:9ba5f110a0b3
      Z@1                       1:925d80f479bb
      foo                       3:9ba5f110a0b3
      foo@1                     0:f7b1eb17ad24
      foo@2                     2:db815d6d32e6
      four                      3:9ba5f110a0b3
      should-end-on-two         2:db815d6d32e6
 
 pull --update works the same as pull && update (case #2)
 
 It is assumed that "hg pull" itself doesn't update current active
 bookmark ('Y' in tests below).
 
   $ hg pull -q ../cloned-bookmarks-update
   divergent bookmark Z stored as Z@2
 
 (pulling revision on another named branch with --update updates
 neither the working directory nor current active bookmark: "no-op"
 case)
 
   $ echo yy >> y
   $ hg commit -m yy
 
   $ hg -R ../cloned-bookmarks-update bookmarks | grep ' Y '
    * Y                         3:125c9a1d6df6
   $ hg -R ../cloned-bookmarks-update pull . --update
   pulling from .
   searching for changes
   adding changesets
   adding manifests
   adding file changes
-  added 1 changesets with 1 changes to 1 files
   divergent bookmark Z stored as Z@default
   adding remote bookmark foo
   adding remote bookmark four
   adding remote bookmark should-end-on-two
+  added 1 changesets with 1 changes to 1 files
   new changesets 5fb12f0f2d51
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R ../cloned-bookmarks-update parents -T "{rev}:{node|short}\n"
   3:125c9a1d6df6
   $ hg -R ../cloned-bookmarks-update bookmarks | grep ' Y '
    * Y                         3:125c9a1d6df6
 
 (pulling revision on current named/topological branch with --update
 updates the working directory and current active bookmark)
 
   $ hg update -C -q 125c9a1d6df6
   $ echo xx >> x
   $ hg commit -m xx
 
   $ hg -R ../cloned-bookmarks-update bookmarks | grep ' Y '
    * Y                         3:125c9a1d6df6
   $ hg -R ../cloned-bookmarks-update pull . --update
   pulling from .
   searching for changes
   adding changesets
   adding manifests
   adding file changes
+  divergent bookmark Z stored as Z@default
   added 1 changesets with 1 changes to 1 files
-  divergent bookmark Z stored as Z@default
   new changesets 81dcce76aa0b
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updating bookmark Y
   $ hg -R ../cloned-bookmarks-update parents -T "{rev}:{node|short}\n"
   6:81dcce76aa0b
   $ hg -R ../cloned-bookmarks-update bookmarks | grep ' Y '
    * Y                         6:81dcce76aa0b
 
   $ cd ..
 
 ensure changelog is written before bookmarks
   $ hg init orderrepo
   $ cd orderrepo
   $ touch a
   $ hg commit -Aqm one
   $ hg book mybook
   $ echo a > a
 
   $ cat > $TESTTMP/pausefinalize.py <<EOF
   > from __future__ import absolute_import
   > import os
   > import time
   > from mercurial import extensions, localrepo
   > def transaction(orig, self, desc, report=None):
   >    tr = orig(self, desc, report)
   >    def sleep(*args, **kwargs):
   >        retry = 20
   >        while retry > 0 and not os.path.exists(b"$TESTTMP/unpause"):
   >            retry -= 1
   >            time.sleep(0.5)
   >        if os.path.exists(b"$TESTTMP/unpause"):
   >            os.remove(b"$TESTTMP/unpause")
   >    # It is important that this finalizer start with 'a', so it runs before
   >    # the changelog finalizer appends to the changelog.
   >    tr.addfinalize(b'a-sleep', sleep)
   >    return tr
   > 
   > def extsetup(ui):
   >    # This extension inserts an artifical pause during the transaction
   >    # finalizer, so we can run commands mid-transaction-close.
   >    extensions.wrapfunction(localrepo.localrepository, 'transaction',
   >                            transaction)
   > EOF
   $ hg commit -qm two --config extensions.pausefinalize=$TESTTMP/pausefinalize.py &
   $ sleep 2
   $ hg log -r .
   changeset:   0:867bc5792c8c
   bookmark:    mybook
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     one
   
   $ hg bookmarks
    * mybook                    0:867bc5792c8c
   $ touch $TESTTMP/unpause
 
   $ cd ..
 
 check whether HG_PENDING makes pending changes only in related
 repositories visible to an external hook.
 
 (emulate a transaction running concurrently by copied
 .hg/bookmarks.pending in subsequent test)
 
   $ cat > $TESTTMP/savepending.sh <<EOF
   > cp .hg/bookmarks.pending .hg/bookmarks.pending.saved
   > exit 1 # to avoid adding new bookmark for subsequent tests
   > EOF
 
   $ hg init unrelated
   $ cd unrelated
   $ echo a > a
   $ hg add a
   $ hg commit -m '#0'
   $ hg --config hooks.pretxnclose="sh $TESTTMP/savepending.sh" bookmarks INVISIBLE
   transaction abort!
   rollback completed
   abort: pretxnclose hook exited with status 1
   [255]
   $ cp .hg/bookmarks.pending.saved .hg/bookmarks.pending
 
 (check visible bookmarks while transaction running in repo)
 
   $ cat > $TESTTMP/checkpending.sh <<EOF
   > echo "@repo"
   > hg -R "$TESTTMP/repo" bookmarks
   > echo "@unrelated"
   > hg -R "$TESTTMP/unrelated" bookmarks
   > exit 1 # to avoid adding new bookmark for subsequent tests
   > EOF
 
   $ cd ../repo
   $ hg --config hooks.pretxnclose="sh $TESTTMP/checkpending.sh" bookmarks NEW
   @repo
    * NEW                       6:81dcce76aa0b
      X2                        1:925d80f479bb
      Y                         4:125c9a1d6df6
      Z                         5:5fb12f0f2d51
      Z@1                       1:925d80f479bb
      Z@2                       4:125c9a1d6df6
      foo                       3:9ba5f110a0b3
      foo@1                     0:f7b1eb17ad24
      foo@2                     2:db815d6d32e6
      four                      3:9ba5f110a0b3
      should-end-on-two         2:db815d6d32e6
      x  y                      2:db815d6d32e6
   @unrelated
   no bookmarks set
   transaction abort!
   rollback completed
   abort: pretxnclose hook exited with status 1
   [255]
 
 Check pretxnclose-bookmark can abort a transaction
 --------------------------------------------------
 
 add hooks:
 
 * to prevent NEW bookmark on a non-public changeset
 * to prevent non-forward move of NEW bookmark
 
   $ cat << EOF >> .hg/hgrc
   > [hooks]
   > pretxnclose-bookmark.force-public  = sh -c "(echo \$HG_BOOKMARK| grep -v NEW > /dev/null) || [ -z \"\$HG_NODE\" ] || (hg log -r \"\$HG_NODE\" -T '{phase}' | grep public > /dev/null)"
   > pretxnclose-bookmark.force-forward = sh -c "(echo \$HG_BOOKMARK| grep -v NEW > /dev/null) || [ -z \"\$HG_NODE\" ] || (hg log -r \"max(\$HG_OLDNODE::\$HG_NODE)\" -T 'MATCH' | grep MATCH > /dev/null)"
   > EOF
 
   $ hg log -G -T phases
   @  changeset:   6:81dcce76aa0b
   |  tag:         tip
   |  phase:       draft
   |  parent:      4:125c9a1d6df6
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     xx
   |
   | o  changeset:   5:5fb12f0f2d51
   | |  branch:      test
   | |  bookmark:    Z
   | |  phase:       draft
   | |  parent:      3:9ba5f110a0b3
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     yy
   | |
   o |  changeset:   4:125c9a1d6df6
   | |  bookmark:    Y
   | |  bookmark:    Z@2
   | |  phase:       public
   | |  parent:      2:db815d6d32e6
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     x
   | |
   | o  changeset:   3:9ba5f110a0b3
   |/   branch:      test
   |    bookmark:    foo
   |    bookmark:    four
   |    phase:       public
   |    user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     y
   |
   o  changeset:   2:db815d6d32e6
   |  bookmark:    foo@2
   |  bookmark:    should-end-on-two
   |  bookmark:    x  y
   |  phase:       public
   |  parent:      0:f7b1eb17ad24
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     2
   |
   | o  changeset:   1:925d80f479bb
   |/   bookmark:    X2
   |    bookmark:    Z@1
   |    phase:       public
   |    user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     1
   |
   o  changeset:   0:f7b1eb17ad24
      bookmark:    foo@1
      phase:       public
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     0
   
 
 attempt to create on a default changeset
 
   $ hg bookmark -r 81dcce76aa0b NEW
   transaction abort!
   rollback completed
   abort: pretxnclose-bookmark.force-public hook exited with status 1
   [255]
 
 create on a public changeset
 
   $ hg bookmark -r 9ba5f110a0b3 NEW
 
 move to the other branch
 
   $ hg bookmark -f -r 125c9a1d6df6 NEW
   transaction abort!
   rollback completed
   abort: pretxnclose-bookmark.force-forward hook exited with status 1
   [255]

tests/test-bundle2-exchange.t

@@ -1,1166 +1,1151 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"
   > logtemplate={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)
-  pre-close-tip:02de42196ebe draft 
   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
-  pre-close-tip:9520eea781bc draft 
   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)
-  pre-close-tip:24b6387c8c8c draft 
   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: pre-close-tip:eea13746799a public book_eea1
   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
-  added 1 changesets with 1 changes to 1 files (+1 heads)
   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
-  added 1 changesets with 1 changes to 1 files (+1 heads)
   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: pre-close-tip:5fddd98957c8 draft book_5fdd
   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: pre-close-tip:32af7686d403 public book_32af
   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]
 
   $ 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]
 
 
 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]
 
   $ 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]
 
   $ hg -R main push http://localhost:$HGPORT2/ -r e7ec4e813ba6
   pushing to http://localhost:$HGPORT2/
   searching for changes
   abort: missing support for test:unknown
   [255]
 
 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: added 1 changesets with 1 changes to 1 files
   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
   [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: added 1 changesets with 1 changes to 1 files
   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]
 
   $ 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: added 1 changesets with 1 changes to 1 files
   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]
 
 (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: added 1 changesets with 1 changes to 1 files
   remote: Fail early!
   remote: transaction abort!
   remote: Cleaning up the mess...
   remote: rollback completed
   abort: pretxnchangegroup hook exited with status 1
   [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: added 1 changesets with 1 changes to 1 files
   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]
   $ 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: added 1 changesets with 1 changes to 1 files
   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]
 
 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
-  added 1 changesets with 1 changes to 1 files
   Fail early!
   transaction abort!
   Cleaning up the mess...
   rollback completed
   abort: pretxnchangegroup hook exited with status 1
   [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: added 1 changesets with 1 changes to 1 files
   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]
   $ 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: added 1 changesets with 1 changes to 1 files
   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]
 
 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
-  added 1 changesets with 1 changes to 1 files
   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: added 1 changesets with 1 changes to 1 files
   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: added 1 changesets with 1 changes to 1 files
   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
-  added 1 changesets with 1 changes to 1 files
   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: added 1 changesets with 1 changes to 1 files
   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: added 1 changesets with 1 changes to 1 files
   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]
 
   $ 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)
   [255]
   $ 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)
   [255]
 
   $ 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)
   [255]
   $ 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)
   [255]
 
   $ 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)
   [255]
 
 (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-format.t

@@ -1,1237 +1,1236 b''
 This test is dedicated to test the bundle2 container format
 
 It test multiple existing parts to test different feature of the container. You
 probably do not need to touch this test unless you change the binary encoding
 of the bundle2 format itself.
 
 Create an extension to test bundle2 API
 
   $ cat > bundle2.py << EOF
   > """A small extension to test bundle2 implementation
   > 
   > This extension allows detailed testing of the various bundle2 API and
   > behaviors.
   > """
   > import gc
   > import os
   > import sys
   > from mercurial import util
   > from mercurial import bundle2
   > from mercurial import scmutil
   > from mercurial import discovery
   > from mercurial import changegroup
   > from mercurial import error
   > from mercurial import obsolete
   > from mercurial import pycompat
   > from mercurial import registrar
   > 
   > 
   > try:
   >     import msvcrt
   >     msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
   >     msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
   >     msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
   > except ImportError:
   >     pass
   > 
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > 
   > ELEPHANTSSONG = b"""Patali Dirapata, Cromda Cromda Ripalo, Pata Pata, Ko Ko Ko
   > Bokoro Dipoulito, Rondi Rondi Pepino, Pata Pata, Ko Ko Ko
   > Emana Karassoli, Loucra Loucra Ponponto, Pata Pata, Ko Ko Ko."""
   > assert len(ELEPHANTSSONG) == 178 # future test say 178 bytes, trust it.
   > 
   > @bundle2.parthandler(b'test:song')
   > def songhandler(op, part):
   >     """handle a "test:song" bundle2 part, printing the lyrics on stdin"""
   >     op.ui.write(b'The choir starts singing:\n')
   >     verses = 0
   >     for line in part.read().split(b'\n'):
   >         op.ui.write(b'    %s\n' % line)
   >         verses += 1
   >     op.records.add(b'song', {b'verses': verses})
   > 
   > @bundle2.parthandler(b'test:ping')
   > def pinghandler(op, part):
   >     op.ui.write(b'received ping request (id %i)\n' % part.id)
   >     if op.reply is not None and b'ping-pong' in op.reply.capabilities:
   >         op.ui.write_err(b'replying to ping request (id %i)\n' % part.id)
   >         op.reply.newpart(b'test:pong', [(b'in-reply-to', b'%d' % part.id)],
   >                          mandatory=False)
   > 
   > @bundle2.parthandler(b'test:debugreply')
   > def debugreply(op, part):
   >     """print data about the capacity of the bundle reply"""
   >     if op.reply is None:
   >         op.ui.write(b'debugreply: no reply\n')
   >     else:
   >         op.ui.write(b'debugreply: capabilities:\n')
   >         for cap in sorted(op.reply.capabilities):
   >             op.ui.write(b"debugreply:     '%s'\n" % cap)
   >             for val in op.reply.capabilities[cap]:
   >                 op.ui.write(b"debugreply:         '%s'\n" % val)
   > 
   > @command(b'bundle2',
   >          [(b'', b'param', [], b'stream level parameter'),
   >           (b'', b'unknown', False, b'include an unknown mandatory part in the bundle'),
   >           (b'', b'unknownparams', False, b'include an unknown part parameters in the bundle'),
   >           (b'', b'parts', False, b'include some arbitrary parts to the bundle'),
   >           (b'', b'reply', False, b'produce a reply bundle'),
   >           (b'', b'pushrace', False, b'includes a check:head part with unknown nodes'),
   >           (b'', b'genraise', False, b'includes a part that raise an exception during generation'),
   >           (b'', b'timeout', False, b'emulate a timeout during bundle generation'),
   >           (b'r', b'rev', [], b'includes those changeset in the bundle'),
   >           (b'', b'compress', b'', b'compress the stream'),
   >          ],
   >          b'[OUTPUTFILE]')
   > def cmdbundle2(ui, repo, path=None, **opts):
   >     """write a bundle2 container on standard output"""
   >     bundler = bundle2.bundle20(ui)
   >     for p in opts['param']:
   >         p = p.split(b'=', 1)
   >         try:
   >             bundler.addparam(*p)
   >         except error.ProgrammingError as exc:
   >             raise error.Abort(b'%s' % exc)
   > 
   >     if opts['compress']:
   >         bundler.setcompression(opts['compress'])
   > 
   >     if opts['reply']:
   >         capsstring = b'ping-pong\nelephants=babar,celeste\ncity%3D%21=celeste%2Cville'
   >         bundler.newpart(b'replycaps', data=capsstring)
   > 
   >     if opts['pushrace']:
   >         # also serve to test the assignement of data outside of init
   >         part = bundler.newpart(b'check:heads')
   >         part.data = b'01234567890123456789'
   > 
   >     revs = opts['rev']
   >     if 'rev' in opts:
   >         revs = scmutil.revrange(repo, opts['rev'])
   >         if revs:
   >             # very crude version of a changegroup part creation
   >             bundled = repo.revs('%ld::%ld', revs, revs)
   >             headmissing = [c.node() for c in repo.set('heads(%ld)', revs)]
   >             headcommon  = [c.node() for c in repo.set('parents(%ld) - %ld', revs, revs)]
   >             outgoing = discovery.outgoing(repo, headcommon, headmissing)
   >             cg = changegroup.makechangegroup(repo, outgoing, b'01',
   >                                              b'test:bundle2')
   >             bundler.newpart(b'changegroup', data=cg.getchunks(),
   >                             mandatory=False)
   > 
   >     if opts['parts']:
   >        bundler.newpart(b'test:empty', mandatory=False)
   >        # add a second one to make sure we handle multiple parts
   >        bundler.newpart(b'test:empty', mandatory=False)
   >        bundler.newpart(b'test:song', data=ELEPHANTSSONG, mandatory=False)
   >        bundler.newpart(b'test:debugreply', mandatory=False)
   >        mathpart = bundler.newpart(b'test:math')
   >        mathpart.addparam(b'pi', b'3.14')
   >        mathpart.addparam(b'e', b'2.72')
   >        mathpart.addparam(b'cooking', b'raw', mandatory=False)
   >        mathpart.data = b'42'
   >        mathpart.mandatory = False
   >        # advisory known part with unknown mandatory param
   >        bundler.newpart(b'test:song', [(b'randomparam', b'')], mandatory=False)
   >     if opts['unknown']:
   >        bundler.newpart(b'test:unknown', data=b'some random content')
   >     if opts['unknownparams']:
   >        bundler.newpart(b'test:song', [(b'randomparams', b'')])
   >     if opts['parts']:
   >        bundler.newpart(b'test:ping', mandatory=False)
   >     if opts['genraise']:
   >        def genraise():
   >            yield b'first line\n'
   >            raise RuntimeError('Someone set up us the bomb!')
   >        bundler.newpart(b'output', data=genraise(), mandatory=False)
   > 
   >     if path is None:
   >        file = pycompat.stdout
   >     else:
   >         file = open(path, 'wb')
   > 
   >     if opts['timeout']:
   >         bundler.newpart(b'test:song', data=ELEPHANTSSONG, mandatory=False)
   >         for idx, junk in enumerate(bundler.getchunks()):
   >             ui.write(b'%d chunk\n' % idx)
   >             if idx > 4:
   >                 # This throws a GeneratorExit inside the generator, which
   >                 # can cause problems if the exception-recovery code is
   >                 # too zealous. It's important for this test that the break
   >                 # occur while we're in the middle of a part.
   >                 break
   >         gc.collect()
   >         ui.write(b'fake timeout complete.\n')
   >         return
   >     try:
   >         for chunk in bundler.getchunks():
   >             file.write(chunk)
   >     except RuntimeError as exc:
   >         raise error.Abort(exc)
   >     finally:
   >         file.flush()
   > 
   > @command(b'unbundle2', [], b'')
   > def cmdunbundle2(ui, repo, replypath=None):
   >     """process a bundle2 stream from stdin on the current repo"""
   >     try:
   >         tr = None
   >         lock = repo.lock()
   >         tr = repo.transaction(b'processbundle')
   >         try:
   >             unbundler = bundle2.getunbundler(ui, pycompat.stdin)
   >             op = bundle2.processbundle(repo, unbundler, lambda: tr)
   >             tr.close()
   >         except error.BundleValueError as exc:
   >             raise error.Abort(b'missing support for %s' % exc)
   >         except error.PushRaced as exc:
   >             raise error.Abort(b'push race: %s' % exc)
   >     finally:
   >         if tr is not None:
   >             tr.release()
   >         lock.release()
   >         remains = pycompat.stdin.read()
   >         ui.write(b'%i unread bytes\n' % len(remains))
   >     if op.records[b'song']:
   >         totalverses = sum(r[b'verses'] for r in op.records[b'song'])
   >         ui.write(b'%i total verses sung\n' % totalverses)
   >     for rec in op.records[b'changegroup']:
   >         ui.write(b'addchangegroup return: %i\n' % rec[b'return'])
   >     if op.reply is not None and replypath is not None:
   >         with open(replypath, 'wb') as file:
   >             for chunk in op.reply.getchunks():
   >                 file.write(chunk)
   > 
   > @command(b'statbundle2', [], b'')
   > def cmdstatbundle2(ui, repo):
   >     """print statistic on the bundle2 container read from stdin"""
   >     unbundler = bundle2.getunbundler(ui, pycompat.stdin)
   >     try:
   >         params = unbundler.params
   >     except error.BundleValueError as exc:
   >        raise error.Abort(b'unknown parameters: %s' % exc)
   >     ui.write(b'options count: %i\n' % len(params))
   >     for key in sorted(params):
   >         ui.write(b'- %s\n' % key)
   >         value = params[key]
   >         if value is not None:
   >             ui.write(b'    %s\n' % value)
   >     count = 0
   >     for p in unbundler.iterparts():
   >         count += 1
   >         ui.write(b'  :%s:\n' % p.type)
   >         ui.write(b'    mandatory: %i\n' % len(p.mandatoryparams))
   >         ui.write(b'    advisory: %i\n' % len(p.advisoryparams))
   >         ui.write(b'    payload: %i bytes\n' % len(p.read()))
   >     ui.write(b'parts count:   %i\n' % count)
   > EOF
   $ cat >> $HGRCPATH << EOF
   > [extensions]
   > bundle2=$TESTTMP/bundle2.py
   > [experimental]
   > evolution.createmarkers=True
   > [ui]
   > ssh="$PYTHON" "$TESTDIR/dummyssh"
   > logtemplate={rev}:{node|short} {phase} {author} {bookmarks} {desc|firstline}
   > [web]
   > push_ssl = false
   > allow_push = *
   > [phases]
   > publish=False
   > EOF
 
 The extension requires a repo (currently unused)
 
   $ hg init main
   $ cd main
   $ touch a
   $ hg add a
   $ hg commit -m 'a'
 
 
 Empty bundle
 =================
 
 - no option
 - no parts
 
 Test bundling
 
   $ hg bundle2 | f --hexdump
   
   0000: 48 47 32 30 00 00 00 00 00 00 00 00             |HG20........|
 
 Test timeouts during bundling
   $ hg bundle2 --timeout --debug --config devel.bundle2.debug=yes
   bundle2-output-bundle: "HG20", 1 parts total
   bundle2-output: start emission of HG20 stream
   0 chunk
   bundle2-output: bundle parameter: 
   1 chunk
   bundle2-output: start of parts
   bundle2-output: bundle part: "test:song"
   bundle2-output-part: "test:song" (advisory) 178 bytes payload
   bundle2-output: part 0: "test:song"
   bundle2-output: header chunk size: 16
   2 chunk
   3 chunk
   bundle2-output: payload chunk size: 178
   4 chunk
   5 chunk
   bundle2-generatorexit
   fake timeout complete.
 
 Test unbundling
 
   $ hg bundle2 | hg statbundle2
   options count: 0
   parts count:   0
 
 Test old style bundle are detected and refused
 
   $ hg bundle --all --type v1 ../bundle.hg
   1 changesets found
   $ hg statbundle2 < ../bundle.hg
   abort: unknown bundle version 10
   [255]
 
 Test parameters
 =================
 
 - some options
 - no parts
 
 advisory parameters, no value
 -------------------------------
 
 Simplest possible parameters form
 
 Test generation simple option
 
   $ hg bundle2 --param 'caution' | f --hexdump
   
   0000: 48 47 32 30 00 00 00 07 63 61 75 74 69 6f 6e 00 |HG20....caution.|
   0010: 00 00 00                                        |...|
 
 Test unbundling
 
   $ hg bundle2 --param 'caution' | hg statbundle2
   options count: 1
   - caution
   parts count:   0
 
 Test generation multiple option
 
   $ hg bundle2 --param 'caution' --param 'meal' | f --hexdump
   
   0000: 48 47 32 30 00 00 00 0c 63 61 75 74 69 6f 6e 20 |HG20....caution |
   0010: 6d 65 61 6c 00 00 00 00                         |meal....|
 
 Test unbundling
 
   $ hg bundle2 --param 'caution' --param 'meal' | hg statbundle2
   options count: 2
   - caution
   - meal
   parts count:   0
 
 advisory parameters, with value
 -------------------------------
 
 Test generation
 
   $ hg bundle2 --param 'caution' --param 'meal=vegan' --param 'elephants' | f --hexdump
   
   0000: 48 47 32 30 00 00 00 1c 63 61 75 74 69 6f 6e 20 |HG20....caution |
   0010: 6d 65 61 6c 3d 76 65 67 61 6e 20 65 6c 65 70 68 |meal=vegan eleph|
   0020: 61 6e 74 73 00 00 00 00                         |ants....|
 
 Test unbundling
 
   $ hg bundle2 --param 'caution' --param 'meal=vegan' --param 'elephants' | hg statbundle2
   options count: 3
   - caution
   - elephants
   - meal
       vegan
   parts count:   0
 
 parameter with special char in value
 ---------------------------------------------------
 
 Test generation
 
   $ hg bundle2 --param 'e|! 7/=babar%#==tutu' --param simple | f --hexdump
   
   0000: 48 47 32 30 00 00 00 29 65 25 37 43 25 32 31 25 |HG20...)e%7C%21%|
   0010: 32 30 37 2f 3d 62 61 62 61 72 25 32 35 25 32 33 |207/=babar%25%23|
   0020: 25 33 44 25 33 44 74 75 74 75 20 73 69 6d 70 6c |%3D%3Dtutu simpl|
   0030: 65 00 00 00 00                                  |e....|
 
 Test unbundling
 
   $ hg bundle2 --param 'e|! 7/=babar%#==tutu' --param simple | hg statbundle2
   options count: 2
   - e|! 7/
       babar%#==tutu
   - simple
   parts count:   0
 
 Test unknown mandatory option
 ---------------------------------------------------
 
   $ hg bundle2 --param 'Gravity' | hg statbundle2
   abort: unknown parameters: Stream Parameter - Gravity
   [255]
 
 Test debug output
 ---------------------------------------------------
 
 bundling debug
 
   $ hg bundle2 --debug --param 'e|! 7/=babar%#==tutu' --param simple ../out.hg2 --config progress.debug=true --config devel.bundle2.debug=true
   bundle2-output-bundle: "HG20", (2 params) 0 parts total
   bundle2-output: start emission of HG20 stream
   bundle2-output: bundle parameter: e%7C%21%207/=babar%25%23%3D%3Dtutu simple
   bundle2-output: start of parts
   bundle2-output: end of bundle
 
 file content is ok
 
   $ f --hexdump ../out.hg2
   ../out.hg2:
   0000: 48 47 32 30 00 00 00 29 65 25 37 43 25 32 31 25 |HG20...)e%7C%21%|
   0010: 32 30 37 2f 3d 62 61 62 61 72 25 32 35 25 32 33 |207/=babar%25%23|
   0020: 25 33 44 25 33 44 74 75 74 75 20 73 69 6d 70 6c |%3D%3Dtutu simpl|
   0030: 65 00 00 00 00                                  |e....|
 
 unbundling debug
 
   $ hg statbundle2 --debug --config progress.debug=true --config devel.bundle2.debug=true < ../out.hg2
   bundle2-input: start processing of HG20 stream
   bundle2-input: reading bundle2 stream parameters
   bundle2-input: ignoring unknown parameter e|! 7/
   bundle2-input: ignoring unknown parameter simple
   options count: 2
   - e|! 7/
       babar%#==tutu
   - simple
   bundle2-input: start extraction of bundle2 parts
   bundle2-input: part header size: 0
   bundle2-input: end of bundle2 stream
   parts count:   0
 
 
 Test buggy input
 ---------------------------------------------------
 
 empty parameter name
 
   $ hg bundle2 --param '' --quiet
   abort: empty parameter name
   [255]
 
 bad parameter name
 
   $ hg bundle2 --param 42babar
   abort: non letter first character: 42babar
   [255]
 
 
 Test part
 =================
 
   $ hg bundle2 --parts ../parts.hg2 --debug --config progress.debug=true --config devel.bundle2.debug=true
   bundle2-output-bundle: "HG20", 7 parts total
   bundle2-output: start emission of HG20 stream
   bundle2-output: bundle parameter: 
   bundle2-output: start of parts
   bundle2-output: bundle part: "test:empty"
   bundle2-output-part: "test:empty" (advisory) empty payload
   bundle2-output: part 0: "test:empty"
   bundle2-output: header chunk size: 17
   bundle2-output: closing payload chunk
   bundle2-output: bundle part: "test:empty"
   bundle2-output-part: "test:empty" (advisory) empty payload
   bundle2-output: part 1: "test:empty"
   bundle2-output: header chunk size: 17
   bundle2-output: closing payload chunk
   bundle2-output: bundle part: "test:song"
   bundle2-output-part: "test:song" (advisory) 178 bytes payload
   bundle2-output: part 2: "test:song"
   bundle2-output: header chunk size: 16
   bundle2-output: payload chunk size: 178
   bundle2-output: closing payload chunk
   bundle2-output: bundle part: "test:debugreply"
   bundle2-output-part: "test:debugreply" (advisory) empty payload
   bundle2-output: part 3: "test:debugreply"
   bundle2-output: header chunk size: 22
   bundle2-output: closing payload chunk
   bundle2-output: bundle part: "test:math"
   bundle2-output-part: "test:math" (advisory) (params: 2 mandatory 2 advisory) 2 bytes payload
   bundle2-output: part 4: "test:math"
   bundle2-output: header chunk size: 43
   bundle2-output: payload chunk size: 2
   bundle2-output: closing payload chunk
   bundle2-output: bundle part: "test:song"
   bundle2-output-part: "test:song" (advisory) (params: 1 mandatory) empty payload
   bundle2-output: part 5: "test:song"
   bundle2-output: header chunk size: 29
   bundle2-output: closing payload chunk
   bundle2-output: bundle part: "test:ping"
   bundle2-output-part: "test:ping" (advisory) empty payload
   bundle2-output: part 6: "test:ping"
   bundle2-output: header chunk size: 16
   bundle2-output: closing payload chunk
   bundle2-output: end of bundle
 
   $ f --hexdump ../parts.hg2
   ../parts.hg2:
   0000: 48 47 32 30 00 00 00 00 00 00 00 11 0a 74 65 73 |HG20.........tes|
   0010: 74 3a 65 6d 70 74 79 00 00 00 00 00 00 00 00 00 |t:empty.........|
   0020: 00 00 00 00 11 0a 74 65 73 74 3a 65 6d 70 74 79 |......test:empty|
   0030: 00 00 00 01 00 00 00 00 00 00 00 00 00 10 09 74 |...............t|
   0040: 65 73 74 3a 73 6f 6e 67 00 00 00 02 00 00 00 00 |est:song........|
   0050: 00 b2 50 61 74 61 6c 69 20 44 69 72 61 70 61 74 |..Patali Dirapat|
   0060: 61 2c 20 43 72 6f 6d 64 61 20 43 72 6f 6d 64 61 |a, Cromda Cromda|
   0070: 20 52 69 70 61 6c 6f 2c 20 50 61 74 61 20 50 61 | Ripalo, Pata Pa|
   0080: 74 61 2c 20 4b 6f 20 4b 6f 20 4b 6f 0a 42 6f 6b |ta, Ko Ko Ko.Bok|
   0090: 6f 72 6f 20 44 69 70 6f 75 6c 69 74 6f 2c 20 52 |oro Dipoulito, R|
   00a0: 6f 6e 64 69 20 52 6f 6e 64 69 20 50 65 70 69 6e |ondi Rondi Pepin|
   00b0: 6f 2c 20 50 61 74 61 20 50 61 74 61 2c 20 4b 6f |o, Pata Pata, Ko|
   00c0: 20 4b 6f 20 4b 6f 0a 45 6d 61 6e 61 20 4b 61 72 | Ko Ko.Emana Kar|
   00d0: 61 73 73 6f 6c 69 2c 20 4c 6f 75 63 72 61 20 4c |assoli, Loucra L|
   00e0: 6f 75 63 72 61 20 50 6f 6e 70 6f 6e 74 6f 2c 20 |oucra Ponponto, |
   00f0: 50 61 74 61 20 50 61 74 61 2c 20 4b 6f 20 4b 6f |Pata Pata, Ko Ko|
   0100: 20 4b 6f 2e 00 00 00 00 00 00 00 16 0f 74 65 73 | Ko..........tes|
   0110: 74 3a 64 65 62 75 67 72 65 70 6c 79 00 00 00 03 |t:debugreply....|
   0120: 00 00 00 00 00 00 00 00 00 2b 09 74 65 73 74 3a |.........+.test:|
   0130: 6d 61 74 68 00 00 00 04 02 01 02 04 01 04 07 03 |math............|
   0140: 70 69 33 2e 31 34 65 32 2e 37 32 63 6f 6f 6b 69 |pi3.14e2.72cooki|
   0150: 6e 67 72 61 77 00 00 00 02 34 32 00 00 00 00 00 |ngraw....42.....|
   0160: 00 00 1d 09 74 65 73 74 3a 73 6f 6e 67 00 00 00 |....test:song...|
   0170: 05 01 00 0b 00 72 61 6e 64 6f 6d 70 61 72 61 6d |.....randomparam|
   0180: 00 00 00 00 00 00 00 10 09 74 65 73 74 3a 70 69 |.........test:pi|
   0190: 6e 67 00 00 00 06 00 00 00 00 00 00 00 00 00 00 |ng..............|
 
 
   $ hg statbundle2 < ../parts.hg2
   options count: 0
     :test:empty:
       mandatory: 0
       advisory: 0
       payload: 0 bytes
     :test:empty:
       mandatory: 0
       advisory: 0
       payload: 0 bytes
     :test:song:
       mandatory: 0
       advisory: 0
       payload: 178 bytes
     :test:debugreply:
       mandatory: 0
       advisory: 0
       payload: 0 bytes
     :test:math:
       mandatory: 2
       advisory: 1
       payload: 2 bytes
     :test:song:
       mandatory: 1
       advisory: 0
       payload: 0 bytes
     :test:ping:
       mandatory: 0
       advisory: 0
       payload: 0 bytes
   parts count:   7
 
   $ hg statbundle2 --debug --config progress.debug=true --config devel.bundle2.debug=true < ../parts.hg2
   bundle2-input: start processing of HG20 stream
   bundle2-input: reading bundle2 stream parameters
   options count: 0
   bundle2-input: start extraction of bundle2 parts
   bundle2-input: part header size: 17
   bundle2-input: part type: "test:empty"
   bundle2-input: part id: "0"
   bundle2-input: part parameters: 0
     :test:empty:
       mandatory: 0
       advisory: 0
   bundle2-input: payload chunk size: 0
       payload: 0 bytes
   bundle2-input: part header size: 17
   bundle2-input: part type: "test:empty"
   bundle2-input: part id: "1"
   bundle2-input: part parameters: 0
     :test:empty:
       mandatory: 0
       advisory: 0
   bundle2-input: payload chunk size: 0
       payload: 0 bytes
   bundle2-input: part header size: 16
   bundle2-input: part type: "test:song"
   bundle2-input: part id: "2"
   bundle2-input: part parameters: 0
     :test:song:
       mandatory: 0
       advisory: 0
   bundle2-input: payload chunk size: 178
   bundle2-input: payload chunk size: 0
   bundle2-input-part: total payload size 178
       payload: 178 bytes
   bundle2-input: part header size: 22
   bundle2-input: part type: "test:debugreply"
   bundle2-input: part id: "3"
   bundle2-input: part parameters: 0
     :test:debugreply:
       mandatory: 0
       advisory: 0
   bundle2-input: payload chunk size: 0
       payload: 0 bytes
   bundle2-input: part header size: 43
   bundle2-input: part type: "test:math"
   bundle2-input: part id: "4"
   bundle2-input: part parameters: 3
     :test:math:
       mandatory: 2
       advisory: 1
   bundle2-input: payload chunk size: 2
   bundle2-input: payload chunk size: 0
   bundle2-input-part: total payload size 2
       payload: 2 bytes
   bundle2-input: part header size: 29
   bundle2-input: part type: "test:song"
   bundle2-input: part id: "5"
   bundle2-input: part parameters: 1
     :test:song:
       mandatory: 1
       advisory: 0
   bundle2-input: payload chunk size: 0
       payload: 0 bytes
   bundle2-input: part header size: 16
   bundle2-input: part type: "test:ping"
   bundle2-input: part id: "6"
   bundle2-input: part parameters: 0
     :test:ping:
       mandatory: 0
       advisory: 0
   bundle2-input: payload chunk size: 0
       payload: 0 bytes
   bundle2-input: part header size: 0
   bundle2-input: end of bundle2 stream
   parts count:   7
 
 Test actual unbundling of test part
 =======================================
 
 Process the bundle
 
   $ hg unbundle2 --debug --config progress.debug=true --config devel.bundle2.debug=true < ../parts.hg2
   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: 17
   bundle2-input: part type: "test:empty"
   bundle2-input: part id: "0"
   bundle2-input: part parameters: 0
   bundle2-input: ignoring unsupported advisory part test:empty
   bundle2-input-part: "test:empty" (advisory) unsupported-type
   bundle2-input: payload chunk size: 0
   bundle2-input: part header size: 17
   bundle2-input: part type: "test:empty"
   bundle2-input: part id: "1"
   bundle2-input: part parameters: 0
   bundle2-input: ignoring unsupported advisory part test:empty
   bundle2-input-part: "test:empty" (advisory) unsupported-type
   bundle2-input: payload chunk size: 0
   bundle2-input: part header size: 16
   bundle2-input: part type: "test:song"
   bundle2-input: part id: "2"
   bundle2-input: part parameters: 0
   bundle2-input: found a handler for part test:song
   bundle2-input-part: "test:song" (advisory) supported
   The choir starts singing:
   bundle2-input: payload chunk size: 178
   bundle2-input: payload chunk size: 0
   bundle2-input-part: total payload size 178
       Patali Dirapata, Cromda Cromda Ripalo, Pata Pata, Ko Ko Ko
       Bokoro Dipoulito, Rondi Rondi Pepino, Pata Pata, Ko Ko Ko
       Emana Karassoli, Loucra Loucra Ponponto, Pata Pata, Ko Ko Ko.
   bundle2-input: part header size: 22
   bundle2-input: part type: "test:debugreply"
   bundle2-input: part id: "3"
   bundle2-input: part parameters: 0
   bundle2-input: found a handler for part test:debugreply
   bundle2-input-part: "test:debugreply" (advisory) supported
   debugreply: no reply
   bundle2-input: payload chunk size: 0
   bundle2-input: part header size: 43
   bundle2-input: part type: "test:math"
   bundle2-input: part id: "4"
   bundle2-input: part parameters: 3
   bundle2-input: ignoring unsupported advisory part test:math
   bundle2-input-part: "test:math" (advisory) (params: 2 mandatory 2 advisory) unsupported-type
   bundle2-input: payload chunk size: 2
   bundle2-input: payload chunk size: 0
   bundle2-input-part: total payload size 2
   bundle2-input: part header size: 29
   bundle2-input: part type: "test:song"
   bundle2-input: part id: "5"
   bundle2-input: part parameters: 1
   bundle2-input: found a handler for part test:song
   bundle2-input: ignoring unsupported advisory part test:song - randomparam
   bundle2-input-part: "test:song" (advisory) (params: 1 mandatory) unsupported-params (randomparam)
   bundle2-input: payload chunk size: 0
   bundle2-input: part header size: 16
   bundle2-input: part type: "test:ping"
   bundle2-input: part id: "6"
   bundle2-input: part parameters: 0
   bundle2-input: found a handler for part test:ping
   bundle2-input-part: "test:ping" (advisory) supported
   received ping request (id 6)
   bundle2-input: payload chunk size: 0
   bundle2-input: part header size: 0
   bundle2-input: end of bundle2 stream
   bundle2-input-bundle: 6 parts total
   0 unread bytes
   3 total verses sung
 
 Unbundle with an unknown mandatory part
 (should abort)
 
   $ hg bundle2 --parts --unknown ../unknown.hg2
 
   $ hg unbundle2 < ../unknown.hg2
   The choir starts singing:
       Patali Dirapata, Cromda Cromda Ripalo, Pata Pata, Ko Ko Ko
       Bokoro Dipoulito, Rondi Rondi Pepino, Pata Pata, Ko Ko Ko
       Emana Karassoli, Loucra Loucra Ponponto, Pata Pata, Ko Ko Ko.
   debugreply: no reply
   0 unread bytes
   abort: missing support for test:unknown
   [255]
 
 Unbundle with an unknown mandatory part parameters
 (should abort)
 
   $ hg bundle2 --unknownparams ../unknown.hg2
 
   $ hg unbundle2 < ../unknown.hg2
   0 unread bytes
   abort: missing support for test:song - randomparams
   [255]
 
 unbundle with a reply
 
   $ hg bundle2 --parts --reply ../parts-reply.hg2
   $ hg unbundle2 ../reply.hg2 < ../parts-reply.hg2
   0 unread bytes
   3 total verses sung
 
 The reply is a bundle
 
   $ f --hexdump ../reply.hg2
   ../reply.hg2:
   0000: 48 47 32 30 00 00 00 00 00 00 00 1b 06 6f 75 74 |HG20.........out|
   0010: 70 75 74 00 00 00 00 00 01 0b 01 69 6e 2d 72 65 |put........in-re|
   0020: 70 6c 79 2d 74 6f 33 00 00 00 d9 54 68 65 20 63 |ply-to3....The c|
   0030: 68 6f 69 72 20 73 74 61 72 74 73 20 73 69 6e 67 |hoir starts sing|
   0040: 69 6e 67 3a 0a 20 20 20 20 50 61 74 61 6c 69 20 |ing:.    Patali |
   0050: 44 69 72 61 70 61 74 61 2c 20 43 72 6f 6d 64 61 |Dirapata, Cromda|
   0060: 20 43 72 6f 6d 64 61 20 52 69 70 61 6c 6f 2c 20 | Cromda Ripalo, |
   0070: 50 61 74 61 20 50 61 74 61 2c 20 4b 6f 20 4b 6f |Pata Pata, Ko Ko|
   0080: 20 4b 6f 0a 20 20 20 20 42 6f 6b 6f 72 6f 20 44 | Ko.    Bokoro D|
   0090: 69 70 6f 75 6c 69 74 6f 2c 20 52 6f 6e 64 69 20 |ipoulito, Rondi |
   00a0: 52 6f 6e 64 69 20 50 65 70 69 6e 6f 2c 20 50 61 |Rondi Pepino, Pa|
   00b0: 74 61 20 50 61 74 61 2c 20 4b 6f 20 4b 6f 20 4b |ta Pata, Ko Ko K|
   00c0: 6f 0a 20 20 20 20 45 6d 61 6e 61 20 4b 61 72 61 |o.    Emana Kara|
   00d0: 73 73 6f 6c 69 2c 20 4c 6f 75 63 72 61 20 4c 6f |ssoli, Loucra Lo|
   00e0: 75 63 72 61 20 50 6f 6e 70 6f 6e 74 6f 2c 20 50 |ucra Ponponto, P|
   00f0: 61 74 61 20 50 61 74 61 2c 20 4b 6f 20 4b 6f 20 |ata Pata, Ko Ko |
   0100: 4b 6f 2e 0a 00 00 00 00 00 00 00 1b 06 6f 75 74 |Ko...........out|
   0110: 70 75 74 00 00 00 01 00 01 0b 01 69 6e 2d 72 65 |put........in-re|
   0120: 70 6c 79 2d 74 6f 34 00 00 00 c9 64 65 62 75 67 |ply-to4....debug|
   0130: 72 65 70 6c 79 3a 20 63 61 70 61 62 69 6c 69 74 |reply: capabilit|
   0140: 69 65 73 3a 0a 64 65 62 75 67 72 65 70 6c 79 3a |ies:.debugreply:|
   0150: 20 20 20 20 20 27 63 69 74 79 3d 21 27 0a 64 65 |     'city=!'.de|
   0160: 62 75 67 72 65 70 6c 79 3a 20 20 20 20 20 20 20 |bugreply:       |
   0170: 20 20 27 63 65 6c 65 73 74 65 2c 76 69 6c 6c 65 |  'celeste,ville|
   0180: 27 0a 64 65 62 75 67 72 65 70 6c 79 3a 20 20 20 |'.debugreply:   |
   0190: 20 20 27 65 6c 65 70 68 61 6e 74 73 27 0a 64 65 |  'elephants'.de|
   01a0: 62 75 67 72 65 70 6c 79 3a 20 20 20 20 20 20 20 |bugreply:       |
   01b0: 20 20 27 62 61 62 61 72 27 0a 64 65 62 75 67 72 |  'babar'.debugr|
   01c0: 65 70 6c 79 3a 20 20 20 20 20 20 20 20 20 27 63 |eply:         'c|
   01d0: 65 6c 65 73 74 65 27 0a 64 65 62 75 67 72 65 70 |eleste'.debugrep|
   01e0: 6c 79 3a 20 20 20 20 20 27 70 69 6e 67 2d 70 6f |ly:     'ping-po|
   01f0: 6e 67 27 0a 00 00 00 00 00 00 00 1e 09 74 65 73 |ng'..........tes|
   0200: 74 3a 70 6f 6e 67 00 00 00 02 01 00 0b 01 69 6e |t:pong........in|
   0210: 2d 72 65 70 6c 79 2d 74 6f 37 00 00 00 00 00 00 |-reply-to7......|
   0220: 00 1b 06 6f 75 74 70 75 74 00 00 00 03 00 01 0b |...output.......|
   0230: 01 69 6e 2d 72 65 70 6c 79 2d 74 6f 37 00 00 00 |.in-reply-to7...|
   0240: 3d 72 65 63 65 69 76 65 64 20 70 69 6e 67 20 72 |=received ping r|
   0250: 65 71 75 65 73 74 20 28 69 64 20 37 29 0a 72 65 |equest (id 7).re|
   0260: 70 6c 79 69 6e 67 20 74 6f 20 70 69 6e 67 20 72 |plying to ping r|
   0270: 65 71 75 65 73 74 20 28 69 64 20 37 29 0a 00 00 |equest (id 7)...|
   0280: 00 00 00 00 00 00                               |......|
 
 The reply is valid
 
   $ hg statbundle2 < ../reply.hg2
   options count: 0
     :output:
       mandatory: 0
       advisory: 1
       payload: 217 bytes
     :output:
       mandatory: 0
       advisory: 1
       payload: 201 bytes
     :test:pong:
       mandatory: 1
       advisory: 0
       payload: 0 bytes
     :output:
       mandatory: 0
       advisory: 1
       payload: 61 bytes
   parts count:   4
 
 Unbundle the reply to get the output:
 
   $ hg unbundle2 < ../reply.hg2
   remote: The choir starts singing:
   remote:     Patali Dirapata, Cromda Cromda Ripalo, Pata Pata, Ko Ko Ko
   remote:     Bokoro Dipoulito, Rondi Rondi Pepino, Pata Pata, Ko Ko Ko
   remote:     Emana Karassoli, Loucra Loucra Ponponto, Pata Pata, Ko Ko Ko.
   remote: debugreply: capabilities:
   remote: debugreply:     'city=!'
   remote: debugreply:         'celeste,ville'
   remote: debugreply:     'elephants'
   remote: debugreply:         'babar'
   remote: debugreply:         'celeste'
   remote: debugreply:     'ping-pong'
   remote: received ping request (id 7)
   remote: replying to ping request (id 7)
   0 unread bytes
 
 Test push race detection
 
   $ hg bundle2 --pushrace ../part-race.hg2
 
   $ hg unbundle2 < ../part-race.hg2
   0 unread bytes
   abort: push race: remote repository changed while pushing - please try again
   [255]
 
 Support for changegroup
 ===================================
 
   $ hg unbundle $TESTDIR/bundles/rebase.hg
   adding changesets
   adding manifests
   adding file changes
   added 8 changesets with 7 changes to 7 files (+3 heads)
   new changesets cd010b8cd998:02de42196ebe (8 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
   $ hg log -G
   o  8:02de42196ebe draft Nicolas Dumazet <[e-mail]>  H
   |
   | o  7:eea13746799a draft Nicolas Dumazet <[e-mail]>  G
   |/|
   o |  6:24b6387c8c8c draft Nicolas Dumazet <[e-mail]>  F
   | |
   | o  5:9520eea781bc draft Nicolas Dumazet <[e-mail]>  E
   |/
   | o  4:32af7686d403 draft Nicolas Dumazet <[e-mail]>  D
   | |
   | o  3:5fddd98957c8 draft Nicolas Dumazet <[e-mail]>  C
   | |
   | o  2:42ccdea3bb16 draft Nicolas Dumazet <[e-mail]>  B
   |/
   o  1:cd010b8cd998 draft Nicolas Dumazet <[e-mail]>  A
   
   @  0:3903775176ed draft test  a
   
 
   $ hg bundle2 --debug --config progress.debug=true --config devel.bundle2.debug=true --rev '8+7+5+4' ../rev.hg2
   4 changesets found
   list of changesets:
   32af7686d403cf45b5d95f2d70cebea587ac806a
   9520eea781bcca16c1e15acc0ba14335a0e8e5ba
   eea13746799a9e0bfd88f29d3c2e9dc9389f524f
   02de42196ebee42ef284b6780a87cdc96e8eaab6
   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: "changegroup"
   bundle2-output-part: "changegroup" (advisory) streamed payload
   bundle2-output: part 0: "changegroup"
   bundle2-output: header chunk size: 18
   changesets: 1/4 chunks (25.00%)
   changesets: 2/4 chunks (50.00%)
   changesets: 3/4 chunks (75.00%)
   changesets: 4/4 chunks (100.00%)
   manifests: 1/4 chunks (25.00%)
   manifests: 2/4 chunks (50.00%)
   manifests: 3/4 chunks (75.00%)
   manifests: 4/4 chunks (100.00%)
   files: D 1/3 files (33.33%)
   files: E 2/3 files (66.67%)
   files: H 3/3 files (100.00%)
   bundle2-output: payload chunk size: 1555
   bundle2-output: closing payload chunk
   bundle2-output: end of bundle
 
   $ f --hexdump ../rev.hg2
   ../rev.hg2:
   0000: 48 47 32 30 00 00 00 00 00 00 00 12 0b 63 68 61 |HG20.........cha|
   0010: 6e 67 65 67 72 6f 75 70 00 00 00 00 00 00 00 00 |ngegroup........|
   0020: 06 13 00 00 00 a4 32 af 76 86 d4 03 cf 45 b5 d9 |......2.v....E..|
   0030: 5f 2d 70 ce be a5 87 ac 80 6a 5f dd d9 89 57 c8 |_-p......j_...W.|
   0040: a5 4a 4d 43 6d fe 1d a9 d8 7f 21 a1 b9 7b 00 00 |.JMCm.....!..{..|
   0050: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
   0060: 00 00 32 af 76 86 d4 03 cf 45 b5 d9 5f 2d 70 ce |..2.v....E.._-p.|
   0070: be a5 87 ac 80 6a 00 00 00 00 00 00 00 29 00 00 |.....j.......)..|
   0080: 00 29 36 65 31 66 34 63 34 37 65 63 62 35 33 33 |.)6e1f4c47ecb533|
   0090: 66 66 64 30 63 38 65 35 32 63 64 63 38 38 61 66 |ffd0c8e52cdc88af|
   00a0: 62 36 63 64 33 39 65 32 30 63 0a 00 00 00 66 00 |b6cd39e20c....f.|
   00b0: 00 00 68 00 00 00 02 44 0a 00 00 00 69 00 00 00 |..h....D....i...|
   00c0: 6a 00 00 00 01 44 00 00 00 a4 95 20 ee a7 81 bc |j....D..... ....|
   00d0: ca 16 c1 e1 5a cc 0b a1 43 35 a0 e8 e5 ba cd 01 |....Z...C5......|
   00e0: 0b 8c d9 98 f3 98 1a 5a 81 15 f9 4f 8d a4 ab 50 |.......Z...O...P|
   00f0: 60 89 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |`...............|
   0100: 00 00 00 00 00 00 95 20 ee a7 81 bc ca 16 c1 e1 |....... ........|
   0110: 5a cc 0b a1 43 35 a0 e8 e5 ba 00 00 00 00 00 00 |Z...C5..........|
   0120: 00 29 00 00 00 29 34 64 65 63 65 39 63 38 32 36 |.)...)4dece9c826|
   0130: 66 36 39 34 39 30 35 30 37 62 39 38 63 36 33 38 |f69490507b98c638|
   0140: 33 61 33 30 30 39 62 32 39 35 38 33 37 64 0a 00 |3a3009b295837d..|
   0150: 00 00 66 00 00 00 68 00 00 00 02 45 0a 00 00 00 |..f...h....E....|
   0160: 69 00 00 00 6a 00 00 00 01 45 00 00 00 a2 ee a1 |i...j....E......|
   0170: 37 46 79 9a 9e 0b fd 88 f2 9d 3c 2e 9d c9 38 9f |7Fy.......<...8.|
   0180: 52 4f 24 b6 38 7c 8c 8c ae 37 17 88 80 f3 fa 95 |RO$.8|...7......|
   0190: de d3 cb 1c f7 85 95 20 ee a7 81 bc ca 16 c1 e1 |....... ........|
   01a0: 5a cc 0b a1 43 35 a0 e8 e5 ba ee a1 37 46 79 9a |Z...C5......7Fy.|
   01b0: 9e 0b fd 88 f2 9d 3c 2e 9d c9 38 9f 52 4f 00 00 |......<...8.RO..|
   01c0: 00 00 00 00 00 29 00 00 00 29 33 36 35 62 39 33 |.....)...)365b93|
   01d0: 64 35 37 66 64 66 34 38 31 34 65 32 62 35 39 31 |d57fdf4814e2b591|
   01e0: 31 64 36 62 61 63 66 66 32 62 31 32 30 31 34 34 |1d6bacff2b120144|
   01f0: 34 31 0a 00 00 00 66 00 00 00 68 00 00 00 00 00 |41....f...h.....|
   0200: 00 00 69 00 00 00 6a 00 00 00 01 47 00 00 00 a4 |..i...j....G....|
   0210: 02 de 42 19 6e be e4 2e f2 84 b6 78 0a 87 cd c9 |..B.n......x....|
   0220: 6e 8e aa b6 24 b6 38 7c 8c 8c ae 37 17 88 80 f3 |n...$.8|...7....|
   0230: fa 95 de d3 cb 1c f7 85 00 00 00 00 00 00 00 00 |................|
   0240: 00 00 00 00 00 00 00 00 00 00 00 00 02 de 42 19 |..............B.|
   0250: 6e be e4 2e f2 84 b6 78 0a 87 cd c9 6e 8e aa b6 |n......x....n...|
   0260: 00 00 00 00 00 00 00 29 00 00 00 29 38 62 65 65 |.......)...)8bee|
   0270: 34 38 65 64 63 37 33 31 38 35 34 31 66 63 30 30 |48edc7318541fc00|
   0280: 31 33 65 65 34 31 62 30 38 39 32 37 36 61 38 63 |13ee41b089276a8c|
   0290: 32 34 62 66 0a 00 00 00 66 00 00 00 66 00 00 00 |24bf....f...f...|
   02a0: 02 48 0a 00 00 00 67 00 00 00 68 00 00 00 01 48 |.H....g...h....H|
   02b0: 00 00 00 00 00 00 00 8b 6e 1f 4c 47 ec b5 33 ff |........n.LG..3.|
   02c0: d0 c8 e5 2c dc 88 af b6 cd 39 e2 0c 66 a5 a0 18 |...,.....9..f...|
   02d0: 17 fd f5 23 9c 27 38 02 b5 b7 61 8d 05 1c 89 e4 |...#.'8...a.....|
   02e0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
   02f0: 00 00 00 00 32 af 76 86 d4 03 cf 45 b5 d9 5f 2d |....2.v....E.._-|
   0300: 70 ce be a5 87 ac 80 6a 00 00 00 81 00 00 00 81 |p......j........|
   0310: 00 00 00 2b 44 00 63 33 66 31 63 61 32 39 32 34 |...+D.c3f1ca2924|
   0320: 63 31 36 61 31 39 62 30 36 35 36 61 38 34 39 30 |c16a19b0656a8490|
   0330: 30 65 35 30 34 65 35 62 30 61 65 63 32 64 0a 00 |0e504e5b0aec2d..|
   0340: 00 00 8b 4d ec e9 c8 26 f6 94 90 50 7b 98 c6 38 |...M...&...P{..8|
   0350: 3a 30 09 b2 95 83 7d 00 7d 8c 9d 88 84 13 25 f5 |:0....}.}.....%.|
   0360: c6 b0 63 71 b3 5b 4e 8a 2b 1a 83 00 00 00 00 00 |..cq.[N.+.......|
   0370: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 95 |................|
   0380: 20 ee a7 81 bc ca 16 c1 e1 5a cc 0b a1 43 35 a0 | ........Z...C5.|
   0390: e8 e5 ba 00 00 00 2b 00 00 00 ac 00 00 00 2b 45 |......+.......+E|
   03a0: 00 39 63 36 66 64 30 33 35 30 61 36 63 30 64 30 |.9c6fd0350a6c0d0|
   03b0: 63 34 39 64 34 61 39 63 35 30 31 37 63 66 30 37 |c49d4a9c5017cf07|
   03c0: 30 34 33 66 35 34 65 35 38 0a 00 00 00 8b 36 5b |043f54e58.....6[|
   03d0: 93 d5 7f df 48 14 e2 b5 91 1d 6b ac ff 2b 12 01 |....H.....k..+..|
   03e0: 44 41 28 a5 84 c6 5e f1 21 f8 9e b6 6a b7 d0 bc |DA(...^.!...j...|
   03f0: 15 3d 80 99 e7 ce 4d ec e9 c8 26 f6 94 90 50 7b |.=....M...&...P{|
   0400: 98 c6 38 3a 30 09 b2 95 83 7d ee a1 37 46 79 9a |..8:0....}..7Fy.|
   0410: 9e 0b fd 88 f2 9d 3c 2e 9d c9 38 9f 52 4f 00 00 |......<...8.RO..|
   0420: 00 56 00 00 00 56 00 00 00 2b 46 00 32 32 62 66 |.V...V...+F.22bf|
   0430: 63 66 64 36 32 61 32 31 61 33 32 38 37 65 64 62 |cfd62a21a3287edb|
   0440: 64 34 64 36 35 36 32 31 38 64 30 66 35 32 35 65 |d4d656218d0f525e|
   0450: 64 37 36 61 0a 00 00 00 97 8b ee 48 ed c7 31 85 |d76a.......H..1.|
   0460: 41 fc 00 13 ee 41 b0 89 27 6a 8c 24 bf 28 a5 84 |A....A..'j.$.(..|
   0470: c6 5e f1 21 f8 9e b6 6a b7 d0 bc 15 3d 80 99 e7 |.^.!...j....=...|
   0480: ce 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
   0490: 00 00 00 00 00 02 de 42 19 6e be e4 2e f2 84 b6 |.......B.n......|
   04a0: 78 0a 87 cd c9 6e 8e aa b6 00 00 00 2b 00 00 00 |x....n......+...|
   04b0: 56 00 00 00 00 00 00 00 81 00 00 00 81 00 00 00 |V...............|
   04c0: 2b 48 00 38 35 30 30 31 38 39 65 37 34 61 39 65 |+H.8500189e74a9e|
   04d0: 30 34 37 35 65 38 32 32 30 39 33 62 63 37 64 62 |0475e822093bc7db|
   04e0: 30 64 36 33 31 61 65 62 30 62 34 0a 00 00 00 00 |0d631aeb0b4.....|
   04f0: 00 00 00 05 44 00 00 00 62 c3 f1 ca 29 24 c1 6a |....D...b...)$.j|
   0500: 19 b0 65 6a 84 90 0e 50 4e 5b 0a ec 2d 00 00 00 |..ej...PN[..-...|
   0510: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
   0520: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
   0530: 00 00 00 00 00 32 af 76 86 d4 03 cf 45 b5 d9 5f |.....2.v....E.._|
   0540: 2d 70 ce be a5 87 ac 80 6a 00 00 00 00 00 00 00 |-p......j.......|
   0550: 00 00 00 00 02 44 0a 00 00 00 00 00 00 00 05 45 |.....D.........E|
   0560: 00 00 00 62 9c 6f d0 35 0a 6c 0d 0c 49 d4 a9 c5 |...b.o.5.l..I...|
   0570: 01 7c f0 70 43 f5 4e 58 00 00 00 00 00 00 00 00 |.|.pC.NX........|
   0580: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
   0590: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
   05a0: 95 20 ee a7 81 bc ca 16 c1 e1 5a cc 0b a1 43 35 |. ........Z...C5|
   05b0: a0 e8 e5 ba 00 00 00 00 00 00 00 00 00 00 00 02 |................|
   05c0: 45 0a 00 00 00 00 00 00 00 05 48 00 00 00 62 85 |E.........H...b.|
   05d0: 00 18 9e 74 a9 e0 47 5e 82 20 93 bc 7d b0 d6 31 |...t..G^. ..}..1|
   05e0: ae b0 b4 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
   05f0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
   0600: 00 00 00 00 00 00 00 00 00 00 00 02 de 42 19 6e |.............B.n|
   0610: be e4 2e f2 84 b6 78 0a 87 cd c9 6e 8e aa b6 00 |......x....n....|
   0620: 00 00 00 00 00 00 00 00 00 00 02 48 0a 00 00 00 |...........H....|
   0630: 00 00 00 00 00 00 00 00 00 00 00 00 00          |.............|
 
   $ hg debugbundle ../rev.hg2
   Stream params: {}
   changegroup -- {} (mandatory: False)
       32af7686d403cf45b5d95f2d70cebea587ac806a
       9520eea781bcca16c1e15acc0ba14335a0e8e5ba
       eea13746799a9e0bfd88f29d3c2e9dc9389f524f
       02de42196ebee42ef284b6780a87cdc96e8eaab6
   $ hg unbundle ../rev.hg2
   adding changesets
   adding manifests
   adding file changes
   added 0 changesets with 0 changes to 3 files
   (run 'hg update' to get a working copy)
 
 with reply
 
   $ hg bundle2 --rev '8+7+5+4' --reply ../rev-rr.hg2
   $ hg unbundle2 ../rev-reply.hg2 < ../rev-rr.hg2
+  added 0 changesets with 0 changes to 3 files
   0 unread bytes
   addchangegroup return: 1
 
   $ f --hexdump ../rev-reply.hg2
   ../rev-reply.hg2:
   0000: 48 47 32 30 00 00 00 00 00 00 00 2f 11 72 65 70 |HG20......./.rep|
   0010: 6c 79 3a 63 68 61 6e 67 65 67 72 6f 75 70 00 00 |ly:changegroup..|
   0020: 00 00 00 02 0b 01 06 01 69 6e 2d 72 65 70 6c 79 |........in-reply|
   0030: 2d 74 6f 31 72 65 74 75 72 6e 31 00 00 00 00 00 |-to1return1.....|
   0040: 00 00 1b 06 6f 75 74 70 75 74 00 00 00 01 00 01 |....output......|
   0050: 0b 01 69 6e 2d 72 65 70 6c 79 2d 74 6f 31 00 00 |..in-reply-to1..|
-  0060: 00 64 61 64 64 69 6e 67 20 63 68 61 6e 67 65 73 |.dadding changes|
+  0060: 00 37 61 64 64 69 6e 67 20 63 68 61 6e 67 65 73 |.7adding changes|
   0070: 65 74 73 0a 61 64 64 69 6e 67 20 6d 61 6e 69 66 |ets.adding manif|
   0080: 65 73 74 73 0a 61 64 64 69 6e 67 20 66 69 6c 65 |ests.adding file|
-  0090: 20 63 68 61 6e 67 65 73 0a 61 64 64 65 64 20 30 | changes.added 0|
-  00a0: 20 63 68 61 6e 67 65 73 65 74 73 20 77 69 74 68 | changesets with|
-  00b0: 20 30 20 63 68 61 6e 67 65 73 20 74 6f 20 33 20 | 0 changes to 3 |
-  00c0: 66 69 6c 65 73 0a 00 00 00 00 00 00 00 00       |files.........|
+  0090: 20 63 68 61 6e 67 65 73 0a 00 00 00 00 00 00 00 | changes........|
+  00a0: 00                                              |.|
 
 Check handling of exception during generation.
 ----------------------------------------------
 
   $ hg bundle2 --genraise > ../genfailed.hg2
   abort: Someone set up us the bomb!
   [255]
 
 Should still be a valid bundle
 
   $ f --hexdump ../genfailed.hg2
   ../genfailed.hg2:
   0000: 48 47 32 30 00 00 00 00 00 00 00 0d 06 6f 75 74 |HG20.........out|
   0010: 70 75 74 00 00 00 00 00 00 ff ff ff ff 00 00 00 |put.............|
   0020: 48 0b 65 72 72 6f 72 3a 61 62 6f 72 74 00 00 00 |H.error:abort...|
   0030: 00 01 00 07 2d 6d 65 73 73 61 67 65 75 6e 65 78 |....-messageunex|
   0040: 70 65 63 74 65 64 20 65 72 72 6f 72 3a 20 53 6f |pected error: So|
   0050: 6d 65 6f 6e 65 20 73 65 74 20 75 70 20 75 73 20 |meone set up us |
   0060: 74 68 65 20 62 6f 6d 62 21 00 00 00 00 00 00 00 |the bomb!.......|
   0070: 00                                              |.|
 
 And its handling on the other size raise a clean exception
 
   $ cat ../genfailed.hg2 | hg unbundle2
   0 unread bytes
   abort: unexpected error: Someone set up us the bomb!
   [255]
 
 Test compression
 ================
 
 Simple case where it just work: GZ
 ----------------------------------
 
   $ hg bundle2 --compress GZ --rev '8+7+5+4' ../rev.hg2.bz
   $ f --hexdump ../rev.hg2.bz
   ../rev.hg2.bz:
   0000: 48 47 32 30 00 00 00 0e 43 6f 6d 70 72 65 73 73 |HG20....Compress|
   0010: 69 6f 6e 3d 47 5a 78 9c 95 94 7d 68 95 55 1c c7 |ion=GZx...}h.U..|
   0020: 9f 3b 31 e8 ce fa c3 65 be a0 a4 b4 52 b9 29 e7 |.;1....e....R.).|
   0030: f5 79 ce 89 fa 63 ed 5e 77 8b 9c c3 3f 2a 1c 68 |.y...c.^w...?*.h|
   0040: cf 79 9b dd 6a ae b0 28 74 b8 e5 96 5b bb 86 61 |.y..j..(t...[..a|
   0050: a3 15 6e 3a 71 c8 6a e8 a5 da 95 64 28 22 ce 69 |..n:q.j....d(".i|
   0060: cd 06 59 34 28 2b 51 2a 58 c3 17 56 2a 9a 9d 67 |..Y4(+Q*X..V*..g|
   0070: dc c6 35 9e c4 1d f8 9e 87 f3 9c f3 3b bf 0f bf |..5.........;...|
   0080: 97 e3 38 ce f4 42 b9 d6 af ae d2 55 af ae 7b ad |..8..B.....U..{.|
   0090: c6 c9 8d bb 8a ec b4 07 ed 7f fd ed d3 53 be 4e |.............S.N|
   00a0: f4 0e af 59 52 73 ea 50 d7 96 9e ba d4 9a 1f 87 |...YRs.P........|
   00b0: 9b 9f 1d e8 7a 6a 79 e9 cb 7f cf eb fe 7e d3 82 |....zjy......~..|
   00c0: ce 2f 36 38 21 23 cc 36 b7 b5 38 90 ab a1 21 92 |./68!#.6..8...!.|
   00d0: 78 5a 0a 8a b1 31 0a 48 a6 29 92 4a 32 e6 1b e1 |xZ...1.H.).J2...|
   00e0: 4a 85 b9 46 40 46 ed 61 63 b5 d6 aa 20 1e ac 5e |[e-mail]... ..^|
   00f0: b0 0a ae 8a c4 03 c6 d6 f9 a3 7b eb fb 4e de 7f |..........{..N..|
   0100: e4 97 55 5f 15 76 96 d2 5d bf 9d 3f 38 18 29 4c |..U_.v..]..?8.)L|
   0110: 0f b7 5d 6e 9b b3 aa 7e c6 d5 15 5b f7 7c 52 f1 |..]n...~...[.|R.|
   0120: 7c 73 18 63 98 6d 3e 23 51 5a 6a 2e 19 72 8d cb ||s.c.m>#QZj..r..|
   0130: 09 07 14 78 82 33 e9 62 86 7d 0c 00 17 88 53 86 |...x.3.b.}....S.|
   0140: 3d 75 0b 63 e2 16 c6 84 9d 76 8f 76 7a cb de fc |=u.c.....v.vz...|
   0150: a8 a3 f0 46 d3 a5 f6 c7 96 b6 9f 60 3b 57 ae 28 |...F.......`;W.(|
   0160: ce b2 8d e9 f4 3e 6f 66 53 dd e5 6b ad 67 be f9 |.....>ofS..k.g..|
   0170: 72 ee 5f 8d 61 3c 61 b6 f9 8c d8 a5 82 63 45 3d |r._.a<a......cE=|
   0180: a3 0c 61 90 68 24 28 87 50 b9 c2 97 c6 20 01 11 |..a.h$(.P.... ..|
   0190: 80 84 10 98 cf e8 e4 13 96 05 51 2c 38 f3 c4 ec |..........Q,8...|
   01a0: ea 43 e7 96 5e 6a c8 be 11 dd 32 78 a2 fa dd 8f |.C..^j....2x....|
   01b0: b3 61 84 61 51 0c b3 cd 27 64 42 6b c2 b4 92 1e |.a.aQ...'dBk....|
   01c0: 86 8c 12 68 24 00 10 db 7f 50 00 c6 91 e7 fa 4c |...h$....P.....L|
   01d0: 22 22 cc bf 84 81 0a 92 c1 aa 2a c7 1b 49 e6 ee |""........*..I..|
   01e0: 6b a9 7e e0 e9 b2 91 5e 7c 73 68 e0 fc 23 3f 34 |k.~....^|sh..#?4|
   01f0: ed cf 0e f2 b3 d3 4c d7 ae 59 33 6f 8c 3d b8 63 |......L..Y3o.=.c|
   0200: 21 2b e8 3d e0 6f 9d 3a b7 f9 dc 24 2a b2 3e a7 |!+.=.o.:...$*.>.|
   0210: 58 dc 91 d8 40 e9 23 8e 88 84 ae 0f b9 00 2e b5 |X...@.#.........|
   0220: 74 36 f3 40 53 40 34 15 c0 d7 12 8d e7 bb 65 f9 |t6.@S@4.......e.|
   0230: c8 ef 03 0f ff f9 fe b6 8a 0d 6d fd ec 51 70 f7 |..........m..Qp.|
   0240: a7 ad 9b 6b 9d da 74 7b 53 43 d1 43 63 fd 19 f9 |...k..t{SC.Cc...|
   0250: ca 67 95 e5 ef c4 e6 6c 9e 44 e1 c5 ac 7a 82 6f |.g.....l.D...z.o|
   0260: c2 e1 d2 b5 2d 81 29 f0 5d 09 6c 6f 10 ae 88 cf |....-.).].lo....|
   0270: 25 05 d0 93 06 78 80 60 43 2d 10 1b 47 71 2b b7 |%....x.`C-..Gq+.|
   0280: 7f bb e9 a7 e4 7d 67 7b df 9b f7 62 cf cd d8 f4 |.....}g{...b....|
   0290: 48 bc 64 51 57 43 ff ea 8b 0b ae 74 64 53 07 86 |H.dQWC.....tdS..|
   02a0: fa 66 3c 5e f7 e1 af a7 c2 90 ff a7 be 9e c9 29 |.f<^...........)|
   02b0: b6 cc 41 48 18 69 94 8b 7c 04 7d 8c 98 a7 95 50 |..AH.i..|.}....P|
   02c0: 44 d9 d0 20 c8 14 30 14 51 ad 6c 16 03 94 0f 5a |D.. ..0.Q.l....Z|
   02d0: 46 93 7f 1c 87 8d 25 d7 9d a2 d1 92 4c f3 c2 54 |F.....%.....L..T|
   02e0: ba f8 70 18 ca 24 0a 29 96 43 71 f2 93 95 74 18 |..p..$.).Cq...t.|
   02f0: b5 65 c4 b8 f6 6c 5c 34 20 1e d5 0c 21 c0 b1 90 |.e...l\4 ...!...|
   0300: 9e 12 40 b9 18 fa 5a 00 41 a2 39 d3 a9 c1 73 21 |..@...Z.A.9...s!|
   0310: 8e 5e 3c b9 b8 f8 48 6a 76 46 a7 1a b6 dd 5b 51 |.^<...HjvF....[Q|
   0320: 5e 19 1d 59 12 c6 32 89 02 9a c0 8f 4f b8 0a ba |^..Y..2.....O...|
   0330: 5e ec 58 37 44 a3 2f dd 33 ed c9 d3 dd c7 22 1b |^.X7D./.3.....".|
   0340: 2f d4 94 8e 95 3f 77 a7 ae 6e f3 32 8d bb 4a 4c |/....?w..n.2..JL|
   0350: b8 0a 5a 43 34 3a b3 3a d6 77 ff 5c b6 fa ad f9 |..ZC4:.:.w.\....|
   0360: db fb 6a 33 df c1 7d 99 cf ef d4 d5 6d da 77 7c |..j3..}.....m.w||
   0370: 3b 19 fd af c5 3f f1 60 c3 17                   |;....?.`..|
   $ hg debugbundle ../rev.hg2.bz
   Stream params: {Compression: GZ}
   changegroup -- {} (mandatory: False)
       32af7686d403cf45b5d95f2d70cebea587ac806a
       9520eea781bcca16c1e15acc0ba14335a0e8e5ba
       eea13746799a9e0bfd88f29d3c2e9dc9389f524f
       02de42196ebee42ef284b6780a87cdc96e8eaab6
   $ hg unbundle ../rev.hg2.bz
   adding changesets
   adding manifests
   adding file changes
   added 0 changesets with 0 changes to 3 files
   (run 'hg update' to get a working copy)
 Simple case where it just work: BZ
 ----------------------------------
 
   $ hg bundle2 --compress BZ --rev '8+7+5+4' ../rev.hg2.bz
   $ f --hexdump ../rev.hg2.bz
   ../rev.hg2.bz:
   0000: 48 47 32 30 00 00 00 0e 43 6f 6d 70 72 65 73 73 |HG20....Compress|
   0010: 69 6f 6e 3d 42 5a 42 5a 68 39 31 41 59 26 53 59 |ion=BZBZh91AY&SY|
   0020: a3 4b 18 3d 00 00 1a 7f ff ff bf 5f f6 ef ef 7f |.K.=......._....|
   0030: f6 3f f7 d1 d9 ff ff f7 6e ff ff 6e f7 f6 bd df |.?......n..n....|
   0040: b5 ab ff cf 67 f6 e7 7b f7 c0 02 d7 33 82 8b 51 |....g..{....3..Q|
   0050: 04 a5 53 d5 3d 27 a0 99 18 4d 0d 34 00 d1 a1 e8 |..S.='...M.4....|
   0060: 80 c8 7a 87 a9 a3 43 6a 3d 46 86 26 80 34 3d 40 |..z...Cj=F.&.4=@|
   0070: c8 c9 b5 34 f4 8f 48 0f 51 ea 34 34 fd 4d aa 19 |...4..H.Q.44.M..|
   0080: 03 40 0c 08 da 86 43 d4 f5 0f 42 1e a0 f3 54 33 |.@....C...B...T3|
   0090: 54 d3 13 4d 03 40 32 00 00 32 03 26 80 0d 00 0d |T..M.@2..2.&....|
   00a0: 00 68 c8 c8 03 20 32 30 98 8c 80 00 00 03 4d 00 |.h... 20......M.|
   00b0: c8 00 00 0d 00 00 22 99 a1 34 c2 64 a6 d5 34 1a |......"..4.d..4.|
   00c0: 00 00 06 86 83 4d 07 a8 d1 a0 68 01 a0 00 00 00 |.....M....h.....|
   00d0: 00 0d 06 80 00 00 00 0d 00 03 40 00 00 04 a4 a1 |..........@.....|
   00e0: 4d a9 89 89 b4 9a 32 0c 43 46 86 87 a9 8d 41 9a |M.....2.CF....A.|
   00f0: 98 46 9a 0d 31 32 1a 34 0d 0c 8d a2 0c 98 4d 06 |.F..12.4......M.|
   0100: 8c 40 c2 60 8d 0d 0c 20 c9 89 fa a0 d0 d3 21 a1 |.@.`... ......!.|
   0110: ea 34 d3 68 9e a6 d1 74 05 33 cb 66 96 93 28 64 |.4.h...t.3.f..(d|
   0120: 40 91 22 ac 55 9b ea 40 7b 38 94 e2 f8 06 00 cb |@.".U..@{8......|
   0130: 28 02 00 4d ab 40 24 10 43 18 cf 64 b4 06 83 0c |(..M.@$.C..d....|
   0140: 34 6c b4 a3 d4 0a 0a e4 a8 5c 4e 23 c0 c9 7a 31 |4l.......\N#..z1|
   0150: 97 87 77 7a 64 88 80 8e 60 97 20 93 0f 8e eb c4 |..wzd...`. .....|
   0160: 62 a4 44 a3 52 20 b2 99 a9 2e e1 d7 29 4a 54 ac |b.D.R ......)JT.|
   0170: 44 7a bb cc 04 3d e0 aa bd 6a 33 5e 9b a2 57 36 |Dz...=...j3^..W6|
   0180: fa cb 45 bb 6d 3e c1 d9 d9 f5 83 69 8a d0 e0 e2 |..E.m>.....i....|
   0190: e7 ae 90 55 24 da 3f ab 78 c0 4c b4 56 a3 9e a4 |...U$.?.x.L.V...|
   01a0: af 9c 65 74 86 ec 6d dc 62 dc 33 ca c8 50 dd 9d |..et..m.b.3..P..|
   01b0: 98 8e 9e 59 20 f3 f0 42 91 4a 09 f5 75 8d 3d a5 |...Y ..B.J..u.=.|
   01c0: a5 15 cb 8d 10 63 b0 c2 2e b2 81 f7 c1 76 0e 53 |.....c.......v.S|
   01d0: 6c 0e 46 73 b5 ae 67 f9 4c 0b 45 6b a8 32 2a 2f |l.Fs..g.L.Ek.2*/|
   01e0: a2 54 a4 44 05 20 a1 38 d1 a4 c6 09 a8 2b 08 99 |.T.D. .8.....+..|
   01f0: a4 14 ae 8d a3 e3 aa 34 27 d8 44 ca c3 5d 21 8b |.......4'.D..]!.|
   0200: 1a 1e 97 29 71 2b 09 4a 4a 55 55 94 58 65 b2 bc |...)q+.JJUU.Xe..|
   0210: f3 a5 90 26 36 76 67 7a 51 98 d6 8a 4a 99 50 b5 |...&6vgzQ...J.P.|
   0220: 99 8f 94 21 17 a9 8b f3 ad 4c 33 d4 2e 40 c8 0c |...!.....L3..@..|
   0230: 3b 90 53 39 db 48 02 34 83 48 d6 b3 99 13 d2 58 |;.S9.H.4.H.....X|
   0240: 65 8e 71 ac a9 06 95 f2 c4 8e b4 08 6b d3 0c ae |e.q.........k...|
   0250: d9 90 56 71 43 a7 a2 62 16 3e 50 63 d3 57 3c 2d |..VqC..b.>Pc.W<-|
   0260: 9f 0f 34 05 08 d8 a6 4b 59 31 54 66 3a 45 0c 8a |..4....KY1Tf:E..|
   0270: c7 90 3a f0 6a 83 1b f5 ca fb 80 2b 50 06 fb 51 |..:.j......+P..Q|
   0280: 7e a6 a4 d4 81 44 82 21 54 00 5b 1a 30 83 62 a3 |~....D.!T.[.0.b.|
   0290: 18 b6 24 19 1e 45 df 4d 5c db a6 af 5b ac 90 fa |..$..E.M\...[...|
   02a0: 3e ed f9 ec 4c ba 36 ee d8 60 20 a7 c7 3b cb d1 |>...L.6..` ..;..|
   02b0: 90 43 7d 27 16 50 5d ad f4 14 07 0b 90 5c cc 6b |.C}'.P]......\.k|
   02c0: 8d 3f a6 88 f4 34 37 a8 cf 14 63 36 19 f7 3e 28 |.?...47...c6..>(|
   02d0: de 99 e8 16 a4 9d 0d 40 a1 a7 24 52 14 a6 72 62 |.......@..$R..rb|
   02e0: 59 5a ca 2d e5 51 90 78 88 d9 c6 c7 21 d0 f7 46 |YZ.-.Q.x....!..F|
   02f0: b2 04 46 44 4e 20 9c 12 b1 03 4e 25 e0 a9 0c 58 |..FDN ....N%...X|
   0300: 5b 1d 3c 93 20 01 51 de a9 1c 69 23 32 46 14 b4 |[.<. .Q...i#2F..|
   0310: 90 db 17 98 98 50 03 90 29 aa 40 b0 13 d8 43 d2 |.....P..).@...C.|
   0320: 5f c5 9d eb f3 f2 ad 41 e8 7a a9 ed a1 58 84 a6 |_......A.z...X..|
   0330: 42 bf d6 fc 24 82 c1 20 32 26 4a 15 a6 1d 29 7f |B...$.. 2&J...).|
   0340: 7e f4 3d 07 bc 62 9a 5b ec 44 3d 72 1d 41 8b 5c |~.=..b.[.D=r.A.\|
   0350: 80 de 0e 62 9a 2e f8 83 00 d5 07 a0 9c c6 74 98 |...b..........t.|
   0360: 11 b2 5e a9 38 02 03 ee fd 86 5c f4 86 b3 ae da |..^.8.....\.....|
   0370: 05 94 01 c5 c6 ea 18 e6 ba 2a ba b3 04 5c 96 89 |.........*...\..|
   0380: 72 63 5b 10 11 f6 67 34 98 cb e4 c0 4e fa e6 99 |rc[...g4....N...|
   0390: 19 6e 50 e8 26 8d 0c 17 e0 be ef e1 8e 02 6f 32 |.nP.&.........o2|
   03a0: 82 dc 26 f8 a1 08 f3 8a 0d f3 c4 75 00 48 73 b8 |..&........u.Hs.|
   03b0: be 3b 0d 7f d0 fd c7 78 96 ec e0 03 80 68 4d 8d |.;.....x.....hM.|
   03c0: 43 8c d7 68 58 f9 50 f0 18 cb 21 58 1b 60 cd 1f |C..hX.P...!X.`..|
   03d0: 84 36 2e 16 1f 0a f7 4e 8f eb df 01 2d c2 79 0b |.6.....N....-.y.|
   03e0: f7 24 ea 0d e8 59 86 51 6e 1c 30 a3 ad 2f ee 8c |.$...Y.Qn.0../..|
   03f0: 90 c8 84 d5 e8 34 c1 95 b2 c9 f6 4d 87 1c 7d 19 |.....4.....M..}.|
   0400: d6 41 58 56 7a e0 6c ba 10 c7 e8 33 39 36 96 e7 |.AXVz.l....396..|
   0410: d2 f9 59 9a 08 95 48 38 e7 0b b7 0a 24 67 c4 39 |..Y...H8....$g.9|
   0420: 8b 43 88 57 9c 01 f5 61 b5 e1 27 41 7e af 83 fe |.C.W...a..'A~...|
   0430: 2e e4 8a 70 a1 21 46 96 30 7a                   |...p.!F.0z|
   $ hg debugbundle ../rev.hg2.bz
   Stream params: {Compression: BZ}
   changegroup -- {} (mandatory: False)
       32af7686d403cf45b5d95f2d70cebea587ac806a
       9520eea781bcca16c1e15acc0ba14335a0e8e5ba
       eea13746799a9e0bfd88f29d3c2e9dc9389f524f
       02de42196ebee42ef284b6780a87cdc96e8eaab6
   $ hg unbundle ../rev.hg2.bz
   adding changesets
   adding manifests
   adding file changes
   added 0 changesets with 0 changes to 3 files
   (run 'hg update' to get a working copy)
 
 unknown compression while unbundling
 -----------------------------
 
   $ hg bundle2 --param Compression=FooBarUnknown --rev '8+7+5+4' ../rev.hg2.bz
   $ cat ../rev.hg2.bz | hg statbundle2
   abort: unknown parameters: Stream Parameter - Compression='FooBarUnknown'
   [255]
   $ hg unbundle ../rev.hg2.bz
   abort: ../rev.hg2.bz: unknown bundle feature, Stream Parameter - Compression='FooBarUnknown'
   (see https://mercurial-scm.org/wiki/BundleFeature for more information)
   [255]
 
   $ cd ..

tests/test-bundle2-multiple-changegroups.t

@@ -1,460 +1,457 b''
 Create an extension to test bundle2 with multiple changegroups
 
   $ cat > bundle2.py <<EOF
   > """
   > """
   > from mercurial import changegroup, discovery, exchange
   > 
   > def _getbundlechangegrouppart(bundler, repo, source, bundlecaps=None,
   >                               b2caps=None, heads=None, common=None,
   >                               **kwargs):
   >     # Create two changegroups given the common changesets and heads for the
   >     # changegroup part we are being requested. Use the parent of each head
   >     # in 'heads' as intermediate heads for the first changegroup.
   >     intermediates = [repo[r].p1().node() for r in heads]
   >     outgoing = discovery.outgoing(repo, common, intermediates)
   >     cg = changegroup.makechangegroup(repo, outgoing, b'01',
   >                                      source, bundlecaps=bundlecaps)
   >     bundler.newpart(b'output', data=b'changegroup1')
   >     bundler.newpart(b'changegroup', data=cg.getchunks())
   >     outgoing = discovery.outgoing(repo, common + intermediates, heads)
   >     cg = changegroup.makechangegroup(repo, outgoing, b'01',
   >                                      source, bundlecaps=bundlecaps)
   >     bundler.newpart(b'output', data=b'changegroup2')
   >     bundler.newpart(b'changegroup', data=cg.getchunks())
   > 
   > def _pull(repo, *args, **kwargs):
   >   pullop = _orig_pull(repo, *args, **kwargs)
   >   repo.ui.write(b'pullop.cgresult is %d\n' % pullop.cgresult)
   >   return pullop
   > 
   > _orig_pull = exchange.pull
   > exchange.pull = _pull
   > exchange.getbundle2partsmapping[b'changegroup'] = _getbundlechangegrouppart
   > EOF
 
   $ cat >> $HGRCPATH << EOF
   > [ui]
   > logtemplate={rev}:{node|short} {phase} {author} {bookmarks} {desc|firstline}
   > EOF
 
 Start with a simple repository with a single commit
 
   $ hg init repo
   $ cd repo
   $ cat > .hg/hgrc << EOF
   > [extensions]
   > bundle2=$TESTTMP/bundle2.py
   > EOF
 
   $ echo A > A
   $ hg commit -A -m A -q
   $ cd ..
 
 Clone
 
   $ hg clone -q repo clone
 
 Add two linear commits
 
   $ cd repo
   $ echo B > B
   $ hg commit -A -m B -q
   $ echo C > C
   $ hg commit -A -m C -q
 
   $ cd ../clone
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > pretxnchangegroup = sh -c "printenv.py --line pretxnchangegroup"
   > changegroup = sh -c "printenv.py --line changegroup"
   > incoming = sh -c "printenv.py --line incoming"
   > EOF
 
 Pull the new commits in the clone
 
   $ hg pull
   pulling from $TESTTMP/repo
   searching for changes
   remote: changegroup1
   adding changesets
   adding manifests
   adding file changes
-  added 1 changesets with 1 changes to 1 files
   pretxnchangegroup hook: HG_HOOKNAME=pretxnchangegroup
   HG_HOOKTYPE=pretxnchangegroup
   HG_NODE=27547f69f25460a52fff66ad004e58da7ad3fb56
   HG_NODE_LAST=27547f69f25460a52fff66ad004e58da7ad3fb56
   HG_PENDING=$TESTTMP/clone
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
   remote: changegroup2
   adding changesets
   adding manifests
   adding file changes
-  added 1 changesets with 1 changes to 1 files
   pretxnchangegroup hook: HG_HOOKNAME=pretxnchangegroup
   HG_HOOKTYPE=pretxnchangegroup
   HG_NODE=f838bfaca5c7226600ebcfd84f3c3c13a28d3757
   HG_NODE_LAST=f838bfaca5c7226600ebcfd84f3c3c13a28d3757
   HG_PENDING=$TESTTMP/clone
   HG_PHASES_MOVED=1
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
+  added 2 changesets with 2 changes to 2 files
   new changesets 27547f69f254:f838bfaca5c7
   changegroup hook: HG_HOOKNAME=changegroup
   HG_HOOKTYPE=changegroup
   HG_NODE=27547f69f25460a52fff66ad004e58da7ad3fb56
   HG_NODE_LAST=27547f69f25460a52fff66ad004e58da7ad3fb56
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
   incoming hook: HG_HOOKNAME=incoming
   HG_HOOKTYPE=incoming
   HG_NODE=27547f69f25460a52fff66ad004e58da7ad3fb56
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
   changegroup hook: HG_HOOKNAME=changegroup
   HG_HOOKTYPE=changegroup
   HG_NODE=f838bfaca5c7226600ebcfd84f3c3c13a28d3757
   HG_NODE_LAST=f838bfaca5c7226600ebcfd84f3c3c13a28d3757
   HG_PHASES_MOVED=1
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
   incoming hook: HG_HOOKNAME=incoming
   HG_HOOKTYPE=incoming
   HG_NODE=f838bfaca5c7226600ebcfd84f3c3c13a28d3757
   HG_PHASES_MOVED=1
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
   pullop.cgresult is 1
   (run 'hg update' to get a working copy)
   $ hg update
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg log -G
   @  2:f838bfaca5c7 public test  C
   |
   o  1:27547f69f254 public test  B
   |
   o  0:4a2df7238c3b public test  A
   
 Add more changesets with multiple heads to the original repository
 
   $ cd ../repo
   $ echo D > D
   $ hg commit -A -m D -q
   $ hg up -r 1
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo E > E
   $ hg commit -A -m E -q
   $ echo F > F
   $ hg commit -A -m F -q
   $ hg up -r 1
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo G > G
   $ hg commit -A -m G -q
   $ hg up -r 3
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo H > H
   $ hg commit -A -m H -q
   $ hg log -G
   @  7:5cd59d311f65 draft test  H
   |
   | o  6:1d14c3ce6ac0 draft test  G
   | |
   | | o  5:7f219660301f draft test  F
   | | |
   | | o  4:8a5212ebc852 draft test  E
   | |/
   o |  3:b3325c91a4d9 draft test  D
   | |
   o |  2:f838bfaca5c7 draft test  C
   |/
   o  1:27547f69f254 draft test  B
   |
   o  0:4a2df7238c3b draft test  A
   
 New heads are reported during transfer and properly accounted for in
 pullop.cgresult
 
   $ cd ../clone
   $ hg pull
   pulling from $TESTTMP/repo
   searching for changes
   remote: changegroup1
   adding changesets
   adding manifests
   adding file changes
-  added 2 changesets with 2 changes to 2 files (+1 heads)
   pretxnchangegroup hook: HG_HOOKNAME=pretxnchangegroup
   HG_HOOKTYPE=pretxnchangegroup
   HG_NODE=b3325c91a4d916bcc4cdc83ea3fe4ece46a42f6e
   HG_NODE_LAST=8a5212ebc8527f9fb821601504794e3eb11a1ed3
   HG_PENDING=$TESTTMP/clone
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
   remote: changegroup2
   adding changesets
   adding manifests
   adding file changes
-  added 3 changesets with 3 changes to 3 files (+1 heads)
   pretxnchangegroup hook: HG_HOOKNAME=pretxnchangegroup
   HG_HOOKTYPE=pretxnchangegroup
   HG_NODE=7f219660301fe4c8a116f714df5e769695cc2b46
   HG_NODE_LAST=5cd59d311f6508b8e0ed28a266756c859419c9f1
   HG_PENDING=$TESTTMP/clone
   HG_PHASES_MOVED=1
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
+  added 5 changesets with 5 changes to 5 files (+2 heads)
   new changesets b3325c91a4d9:5cd59d311f65
   changegroup hook: HG_HOOKNAME=changegroup
   HG_HOOKTYPE=changegroup
   HG_NODE=b3325c91a4d916bcc4cdc83ea3fe4ece46a42f6e
   HG_NODE_LAST=8a5212ebc8527f9fb821601504794e3eb11a1ed3
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
   incoming hook: HG_HOOKNAME=incoming
   HG_HOOKTYPE=incoming
   HG_NODE=b3325c91a4d916bcc4cdc83ea3fe4ece46a42f6e
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
   incoming hook: HG_HOOKNAME=incoming
   HG_HOOKTYPE=incoming
   HG_NODE=8a5212ebc8527f9fb821601504794e3eb11a1ed3
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
   changegroup hook: HG_HOOKNAME=changegroup
   HG_HOOKTYPE=changegroup
   HG_NODE=7f219660301fe4c8a116f714df5e769695cc2b46
   HG_NODE_LAST=5cd59d311f6508b8e0ed28a266756c859419c9f1
   HG_PHASES_MOVED=1
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
   incoming hook: HG_HOOKNAME=incoming
   HG_HOOKTYPE=incoming
   HG_NODE=7f219660301fe4c8a116f714df5e769695cc2b46
   HG_PHASES_MOVED=1
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
   incoming hook: HG_HOOKNAME=incoming
   HG_HOOKTYPE=incoming
   HG_NODE=1d14c3ce6ac0582d2809220d33e8cd7a696e0156
   HG_PHASES_MOVED=1
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
   incoming hook: HG_HOOKNAME=incoming
   HG_HOOKTYPE=incoming
   HG_NODE=5cd59d311f6508b8e0ed28a266756c859419c9f1
   HG_PHASES_MOVED=1
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
   pullop.cgresult is 3
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg log -G
   o  7:5cd59d311f65 public test  H
   |
   | o  6:1d14c3ce6ac0 public test  G
   | |
   | | o  5:7f219660301f public test  F
   | | |
   | | o  4:8a5212ebc852 public test  E
   | |/
   o |  3:b3325c91a4d9 public test  D
   | |
   @ |  2:f838bfaca5c7 public test  C
   |/
   o  1:27547f69f254 public test  B
   |
   o  0:4a2df7238c3b public test  A
   
 Removing a head from the original repository by merging it
 
   $ cd ../repo
   $ hg merge -r 6 -q
   $ hg commit -m Merge
   $ echo I > I
   $ hg commit -A -m H -q
   $ hg log -G
   @  9:9d18e5bd9ab0 draft test  H
   |
   o    8:71bd7b46de72 draft test  Merge
   |\
   | o  7:5cd59d311f65 draft test  H
   | |
   o |  6:1d14c3ce6ac0 draft test  G
   | |
   | | o  5:7f219660301f draft test  F
   | | |
   +---o  4:8a5212ebc852 draft test  E
   | |
   | o  3:b3325c91a4d9 draft test  D
   | |
   | o  2:f838bfaca5c7 draft test  C
   |/
   o  1:27547f69f254 draft test  B
   |
   o  0:4a2df7238c3b draft test  A
   
 Removed heads are reported during transfer and properly accounted for in
 pullop.cgresult
 
   $ cd ../clone
   $ hg pull
   pulling from $TESTTMP/repo
   searching for changes
   remote: changegroup1
   adding changesets
   adding manifests
   adding file changes
-  added 1 changesets with 0 changes to 0 files (-1 heads)
   pretxnchangegroup hook: HG_HOOKNAME=pretxnchangegroup
   HG_HOOKTYPE=pretxnchangegroup
   HG_NODE=71bd7b46de72e69a32455bf88d04757d542e6cf4
   HG_NODE_LAST=71bd7b46de72e69a32455bf88d04757d542e6cf4
   HG_PENDING=$TESTTMP/clone
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
   remote: changegroup2
   adding changesets
   adding manifests
   adding file changes
-  added 1 changesets with 1 changes to 1 files
   pretxnchangegroup hook: HG_HOOKNAME=pretxnchangegroup
   HG_HOOKTYPE=pretxnchangegroup
   HG_NODE=9d18e5bd9ab09337802595d49f1dad0c98df4d84
   HG_NODE_LAST=9d18e5bd9ab09337802595d49f1dad0c98df4d84
   HG_PENDING=$TESTTMP/clone
   HG_PHASES_MOVED=1
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
+  added 2 changesets with 1 changes to 1 files (-1 heads)
   new changesets 71bd7b46de72:9d18e5bd9ab0
   changegroup hook: HG_HOOKNAME=changegroup
   HG_HOOKTYPE=changegroup
   HG_NODE=71bd7b46de72e69a32455bf88d04757d542e6cf4
   HG_NODE_LAST=71bd7b46de72e69a32455bf88d04757d542e6cf4
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
   incoming hook: HG_HOOKNAME=incoming
   HG_HOOKTYPE=incoming
   HG_NODE=71bd7b46de72e69a32455bf88d04757d542e6cf4
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
   changegroup hook: HG_HOOKNAME=changegroup
   HG_HOOKTYPE=changegroup
   HG_NODE=9d18e5bd9ab09337802595d49f1dad0c98df4d84
   HG_NODE_LAST=9d18e5bd9ab09337802595d49f1dad0c98df4d84
   HG_PHASES_MOVED=1
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
   incoming hook: HG_HOOKNAME=incoming
   HG_HOOKTYPE=incoming
   HG_NODE=9d18e5bd9ab09337802595d49f1dad0c98df4d84
   HG_PHASES_MOVED=1
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   file:/*/$TESTTMP/repo (glob)
   HG_URL=file:$TESTTMP/repo
   
   pullop.cgresult is -2
   (run 'hg update' to get a working copy)
   $ hg log -G
   o  9:9d18e5bd9ab0 public test  H
   |
   o    8:71bd7b46de72 public test  Merge
   |\
   | o  7:5cd59d311f65 public test  H
   | |
   o |  6:1d14c3ce6ac0 public test  G
   | |
   | | o  5:7f219660301f public test  F
   | | |
   +---o  4:8a5212ebc852 public test  E
   | |
   | o  3:b3325c91a4d9 public test  D
   | |
   | @  2:f838bfaca5c7 public test  C
   |/
   o  1:27547f69f254 public test  B
   |
   o  0:4a2df7238c3b public test  A
   

tests/test-bundle2-remote-changegroup.t

@@ -1,619 +1,609 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"
   > logtemplate={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
-  added 2 changesets with 2 changes to 2 files (+1 heads)
   remote: changegroup
   adding changesets
   adding manifests
   adding file changes
-  added 3 changesets with 2 changes to 2 files (+1 heads)
+  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
-  added 2 changesets with 2 changes to 2 files (+1 heads)
   remote: remote-changegroup
   adding changesets
   adding manifests
   adding file changes
-  added 3 changesets with 2 changes to 2 files (+1 heads)
+  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
-  added 2 changesets with 2 changes to 2 files (+1 heads)
   remote: remote-changegroup
   adding changesets
   adding manifests
   adding file changes
-  added 2 changesets with 1 changes to 1 files
   remote: changegroup
   adding changesets
   adding manifests
   adding file changes
-  added 1 changesets with 1 changes to 1 files (+1 heads)
+  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
-  added 8 changesets with 7 changes to 7 files (+2 heads)
   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
-  added 8 changesets with 7 changes to 7 files (+2 heads)
   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
-  added 8 changesets with 7 changes to 7 files (+2 heads)
   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
-  added 2 changesets with 2 changes to 2 files (+1 heads)
   remote: remote-changegroup
   adding changesets
   adding manifests
   adding file changes
-  added 2 changesets with 1 changes to 1 files
   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
-  added 2 changesets with 2 changes to 2 files (+1 heads)
   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]
 
 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.t

@@ -1,1301 +1,1301 b''
 #testcases sshv1 sshv2
 
 #if sshv2
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > sshpeer.advertise-v2 = true
   > sshserver.support-v2 = true
   > EOF
 #endif
 
 Prepare repo a:
 
   $ hg init a
   $ cd a
   $ echo a > a
   $ hg add a
   $ hg commit -m test
   $ echo first line > b
   $ hg add b
 
 Create a non-inlined filelog:
 
   $ "$PYTHON" -c 'open("data1", "wb").write(b"".join(b"%d\n" % x for x in range(10000)))'
   $ for j in 0 1 2 3 4 5 6 7 8 9; do
   >   cat data1 >> b
   >   hg commit -m test
   > done
 
 List files in store/data (should show a 'b.d'):
 
 #if reporevlogstore
   $ for i in .hg/store/data/*; do
   >   echo $i
   > done
   .hg/store/data/a.i
   .hg/store/data/b.d
   .hg/store/data/b.i
 #endif
 
 Trigger branchcache creation:
 
   $ hg branches
   default                       10:a7949464abda
   $ ls .hg/cache
   branch2-served
   rbc-names-v1
   rbc-revs-v1
 
 Default operation:
 
   $ hg clone . ../b
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ../b
 
 Ensure branchcache got copied over:
 
   $ ls .hg/cache
   branch2-served
   rbc-names-v1
   rbc-revs-v1
 
   $ cat a
   a
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 11 changesets with 11 changes to 2 files
 
 Invalid dest '' must abort:
 
   $ hg clone . ''
   abort: empty destination path is not valid
   [255]
 
 No update, with debug option:
 
 #if hardlink
   $ hg --debug clone -U . ../c --config progress.debug=true
   linking: 1 files
   linking: 2 files
   linking: 3 files
   linking: 4 files
   linking: 5 files
   linking: 6 files
   linking: 7 files
   linking: 8 files
   linked 8 files (reporevlogstore !)
   linking: 9 files (reposimplestore !)
   linking: 10 files (reposimplestore !)
   linking: 11 files (reposimplestore !)
   linking: 12 files (reposimplestore !)
   linking: 13 files (reposimplestore !)
   linking: 14 files (reposimplestore !)
   linking: 15 files (reposimplestore !)
   linking: 16 files (reposimplestore !)
   linking: 17 files (reposimplestore !)
   linking: 18 files (reposimplestore !)
   linked 18 files (reposimplestore !)
 #else
   $ hg --debug clone -U . ../c --config progress.debug=true
   linking: 1 files
   copying: 2 files
   copying: 3 files
   copying: 4 files
   copying: 5 files
   copying: 6 files
   copying: 7 files
   copying: 8 files
   copied 8 files (reporevlogstore !)
   copying: 9 files (reposimplestore !)
   copying: 10 files (reposimplestore !)
   copying: 11 files (reposimplestore !)
   copying: 12 files (reposimplestore !)
   copying: 13 files (reposimplestore !)
   copying: 14 files (reposimplestore !)
   copying: 15 files (reposimplestore !)
   copying: 16 files (reposimplestore !)
   copying: 17 files (reposimplestore !)
   copying: 18 files (reposimplestore !)
   copied 18 files (reposimplestore !)
 #endif
   $ cd ../c
 
 Ensure branchcache got copied over:
 
   $ ls .hg/cache
   branch2-served
   rbc-names-v1
   rbc-revs-v1
 
   $ cat a 2>/dev/null || echo "a not present"
   a not present
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 11 changesets with 11 changes to 2 files
 
 Default destination:
 
   $ mkdir ../d
   $ cd ../d
   $ hg clone ../a
   destination directory: a
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd a
   $ hg cat a
   a
   $ cd ../..
 
 Check that we drop the 'file:' from the path before writing the .hgrc:
 
   $ hg clone file:a e
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ grep 'file:' e/.hg/hgrc
   [1]
 
 Check that path aliases are expanded:
 
   $ hg clone -q -U --config 'paths.foobar=a#0' foobar f
   $ hg -R f showconfig paths.default
   $TESTTMP/a#0
 
 Use --pull:
 
   $ hg clone --pull a g
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 11 changesets with 11 changes to 2 files
   new changesets acb14030fe0a:a7949464abda
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R g verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 11 changesets with 11 changes to 2 files
 
 Invalid dest '' with --pull must abort (issue2528):
 
   $ hg clone --pull a ''
   abort: empty destination path is not valid
   [255]
 
 Clone to '.':
 
   $ mkdir h
   $ cd h
   $ hg clone ../a .
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
 
 
 *** Tests for option -u ***
 
 Adding some more history to repo a:
 
   $ cd a
   $ hg tag ref1
   $ echo the quick brown fox >a
   $ hg ci -m "hacked default"
   $ hg up ref1
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg branch stable
   marked working directory as branch stable
   (branches are permanent and global, did you want a bookmark?)
   $ echo some text >a
   $ hg ci -m "starting branch stable"
   $ hg tag ref2
   $ echo some more text >a
   $ hg ci -m "another change for branch stable"
   $ hg up ref2
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg parents
   changeset:   13:e8ece76546a6
   branch:      stable
   tag:         ref2
   parent:      10:a7949464abda
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     starting branch stable
   
 
 Repo a has two heads:
 
   $ hg heads
   changeset:   15:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
   changeset:   12:f21241060d6a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     hacked default
   
 
   $ cd ..
 
 
 Testing --noupdate with --updaterev (must abort):
 
   $ hg clone --noupdate --updaterev 1 a ua
   abort: cannot specify both --noupdate and --updaterev
   [255]
 
 
 Testing clone -u:
 
   $ hg clone -u . a ua
   updating to branch stable
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Repo ua has both heads:
 
   $ hg -R ua heads
   changeset:   15:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
   changeset:   12:f21241060d6a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     hacked default
   
 
 Same revision checked out in repo a and ua:
 
   $ hg -R a parents --template "{node|short}\n"
   e8ece76546a6
   $ hg -R ua parents --template "{node|short}\n"
   e8ece76546a6
 
   $ rm -r ua
 
 
 Testing clone --pull -u:
 
   $ hg clone --pull -u . a ua
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 16 changesets with 16 changes to 3 files (+1 heads)
   new changesets acb14030fe0a:0aae7cf88f0d
   updating to branch stable
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Repo ua has both heads:
 
   $ hg -R ua heads
   changeset:   15:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
   changeset:   12:f21241060d6a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     hacked default
   
 
 Same revision checked out in repo a and ua:
 
   $ hg -R a parents --template "{node|short}\n"
   e8ece76546a6
   $ hg -R ua parents --template "{node|short}\n"
   e8ece76546a6
 
   $ rm -r ua
 
 
 Testing clone -u <branch>:
 
   $ hg clone -u stable a ua
   updating to branch stable
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Repo ua has both heads:
 
   $ hg -R ua heads
   changeset:   15:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
   changeset:   12:f21241060d6a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     hacked default
   
 
 Branch 'stable' is checked out:
 
   $ hg -R ua parents
   changeset:   15:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
 
   $ rm -r ua
 
 
 Testing default checkout:
 
   $ hg clone a ua
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Repo ua has both heads:
 
   $ hg -R ua heads
   changeset:   15:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
   changeset:   12:f21241060d6a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     hacked default
   
 
 Branch 'default' is checked out:
 
   $ hg -R ua parents
   changeset:   12:f21241060d6a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     hacked default
   
 Test clone with a branch named "@" (issue3677)
 
   $ hg -R ua branch @
   marked working directory as branch @
   $ hg -R ua commit -m 'created branch @'
   $ hg clone ua atbranch
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R atbranch heads
   changeset:   16:798b6d97153e
   branch:      @
   tag:         tip
   parent:      12:f21241060d6a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     created branch @
   
   changeset:   15:0aae7cf88f0d
   branch:      stable
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
   changeset:   12:f21241060d6a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     hacked default
   
   $ hg -R atbranch parents
   changeset:   12:f21241060d6a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     hacked default
   
 
   $ rm -r ua atbranch
 
 
 Testing #<branch>:
 
   $ hg clone -u . a#stable ua
   adding changesets
   adding manifests
   adding file changes
   added 14 changesets with 14 changes to 3 files
   new changesets acb14030fe0a:0aae7cf88f0d
   updating to branch stable
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Repo ua has branch 'stable' and 'default' (was changed in fd511e9eeea6):
 
   $ hg -R ua heads
   changeset:   13:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
   changeset:   10:a7949464abda
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     test
   
 
 Same revision checked out in repo a and ua:
 
   $ hg -R a parents --template "{node|short}\n"
   e8ece76546a6
   $ hg -R ua parents --template "{node|short}\n"
   e8ece76546a6
 
   $ rm -r ua
 
 
 Testing -u -r <branch>:
 
   $ hg clone -u . -r stable a ua
   adding changesets
   adding manifests
   adding file changes
   added 14 changesets with 14 changes to 3 files
   new changesets acb14030fe0a:0aae7cf88f0d
   updating to branch stable
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Repo ua has branch 'stable' and 'default' (was changed in fd511e9eeea6):
 
   $ hg -R ua heads
   changeset:   13:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
   changeset:   10:a7949464abda
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     test
   
 
 Same revision checked out in repo a and ua:
 
   $ hg -R a parents --template "{node|short}\n"
   e8ece76546a6
   $ hg -R ua parents --template "{node|short}\n"
   e8ece76546a6
 
   $ rm -r ua
 
 
 Testing -r <branch>:
 
   $ hg clone -r stable a ua
   adding changesets
   adding manifests
   adding file changes
   added 14 changesets with 14 changes to 3 files
   new changesets acb14030fe0a:0aae7cf88f0d
   updating to branch stable
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Repo ua has branch 'stable' and 'default' (was changed in fd511e9eeea6):
 
   $ hg -R ua heads
   changeset:   13:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
   changeset:   10:a7949464abda
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     test
   
 
 Branch 'stable' is checked out:
 
   $ hg -R ua parents
   changeset:   13:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
 
   $ rm -r ua
 
 
 Issue2267: Error in 1.6 hg.py: TypeError: 'NoneType' object is not
 iterable in addbranchrevs()
 
   $ cat <<EOF > simpleclone.py
   > from mercurial import hg, ui as uimod
   > myui = uimod.ui.load()
   > repo = hg.repository(myui, b'a')
   > hg.clone(myui, {}, repo, dest=b"ua")
   > EOF
 
   $ "$PYTHON" simpleclone.py
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ rm -r ua
 
   $ cat <<EOF > branchclone.py
   > from mercurial import extensions, hg, ui as uimod
   > myui = uimod.ui.load()
   > extensions.loadall(myui)
   > extensions.populateui(myui)
   > repo = hg.repository(myui, b'a')
   > hg.clone(myui, {}, repo, dest=b"ua", branch=[b"stable"])
   > EOF
 
   $ "$PYTHON" branchclone.py
   adding changesets
   adding manifests
   adding file changes
   added 14 changesets with 14 changes to 3 files
   new changesets acb14030fe0a:0aae7cf88f0d
   updating to branch stable
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ rm -r ua
 
 
 Test clone with special '@' bookmark:
   $ cd a
   $ hg bookmark -r a7949464abda @  # branch point of stable from default
   $ hg clone . ../i
   updating to bookmark @
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -i ../i
   a7949464abda
   $ rm -r ../i
 
   $ hg bookmark -f -r stable @
   $ hg bookmarks
      @                         15:0aae7cf88f0d
   $ hg clone . ../i
   updating to bookmark @ on branch stable
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -i ../i
   0aae7cf88f0d
   $ cd "$TESTTMP"
 
 
 Testing failures:
 
   $ mkdir fail
   $ cd fail
 
 No local source
 
   $ hg clone a b
   abort: repository a not found!
   [255]
 
 No remote source
 
 #if windows
   $ hg clone http://$LOCALIP:3121/a b
   abort: error: * (glob)
   [255]
 #else
   $ hg clone http://$LOCALIP:3121/a b
   abort: error: *refused* (glob)
   [255]
 #endif
   $ rm -rf b # work around bug with http clone
 
 
 #if unix-permissions no-root
 
 Inaccessible source
 
   $ mkdir a
   $ chmod 000 a
   $ hg clone a b
   abort: Permission denied: *$TESTTMP/fail/a/.hg* (glob)
   [255]
 
 Inaccessible destination
 
   $ hg init b
   $ cd b
   $ hg clone . ../a
   abort: Permission denied: *../a* (glob)
   [255]
   $ cd ..
   $ chmod 700 a
   $ rm -r a b
 
 #endif
 
 
 #if fifo
 
 Source of wrong type
 
   $ mkfifo a
   $ hg clone a b
   abort: $ENOTDIR$: *$TESTTMP/fail/a/.hg* (glob)
   [255]
   $ rm a
 
 #endif
 
 Default destination, same directory
 
   $ hg init q
   $ hg clone q
   destination directory: q
   abort: destination 'q' is not empty
   [255]
 
 destination directory not empty
 
   $ mkdir a
   $ echo stuff > a/a
   $ hg clone q a
   abort: destination 'a' is not empty
   [255]
 
 
 #if unix-permissions no-root
 
 leave existing directory in place after clone failure
 
   $ hg init c
   $ cd c
   $ echo c > c
   $ hg commit -A -m test
   adding c
   $ chmod -rx .hg/store/data
   $ cd ..
   $ mkdir d
   $ hg clone c d 2> err
   [255]
   $ test -d d
   $ test -d d/.hg
   [1]
 
 re-enable perm to allow deletion
 
   $ chmod +rx c/.hg/store/data
 
 #endif
 
   $ cd ..
 
 Test clone from the repository in (emulated) revlog format 0 (issue4203):
 
   $ mkdir issue4203
   $ mkdir -p src/.hg
   $ echo foo > src/foo
   $ hg -R src add src/foo
   $ hg -R src commit -m '#0'
   $ hg -R src log -q
   0:e1bab28bca43
   $ hg -R src debugrevlog -c | egrep 'format|flags'
   format : 0
   flags  : (none)
   $ hg root -R src -T json | sed 's|\\\\|\\|g'
   [
    {
     "hgpath": "$TESTTMP/src/.hg",
     "reporoot": "$TESTTMP/src",
     "storepath": "$TESTTMP/src/.hg"
    }
   ]
   $ hg clone -U -q src dst
   $ hg -R dst log -q
   0:e1bab28bca43
 
 Create repositories to test auto sharing functionality
 
   $ cat >> $HGRCPATH << EOF
   > [extensions]
   > share=
   > EOF
 
   $ hg init empty
   $ hg init source1a
   $ cd source1a
   $ echo initial1 > foo
   $ hg -q commit -A -m initial
   $ echo second > foo
   $ hg commit -m second
   $ cd ..
 
   $ hg init filteredrev0
   $ cd filteredrev0
   $ cat >> .hg/hgrc << EOF
   > [experimental]
   > evolution.createmarkers=True
   > EOF
   $ echo initial1 > foo
   $ hg -q commit -A -m initial0
   $ hg -q up -r null
   $ echo initial2 > foo
   $ hg -q commit -A -m initial1
   $ hg debugobsolete c05d5c47a5cf81401869999f3d05f7d699d2b29a e082c1832e09a7d1e78b7fd49a592d372de854c8
   1 new obsolescence markers
   obsoleted 1 changesets
   $ cd ..
 
   $ hg -q clone --pull source1a source1b
   $ cd source1a
   $ hg bookmark bookA
   $ echo 1a > foo
   $ hg commit -m 1a
   $ cd ../source1b
   $ hg -q up -r 0
   $ echo head1 > foo
   $ hg commit -m head1
   created new head
   $ hg bookmark head1
   $ hg -q up -r 0
   $ echo head2 > foo
   $ hg commit -m head2
   created new head
   $ hg bookmark head2
   $ hg -q up -r 0
   $ hg branch branch1
   marked working directory as branch branch1
   (branches are permanent and global, did you want a bookmark?)
   $ echo branch1 > foo
   $ hg commit -m branch1
   $ hg -q up -r 0
   $ hg branch branch2
   marked working directory as branch branch2
   $ echo branch2 > foo
   $ hg commit -m branch2
   $ cd ..
   $ hg init source2
   $ cd source2
   $ echo initial2 > foo
   $ hg -q commit -A -m initial2
   $ echo second > foo
   $ hg commit -m second
   $ cd ..
 
 Clone with auto share from an empty repo should not result in share
 
   $ mkdir share
   $ hg --config share.pool=share clone empty share-empty
   (not using pooled storage: remote appears to be empty)
   updating to branch default
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ ls share
   $ test -d share-empty/.hg/store
   $ test -f share-empty/.hg/sharedpath
   [1]
 
 Clone with auto share from a repo with filtered revision 0 should not result in share
 
   $ hg --config share.pool=share clone filteredrev0 share-filtered
   (not using pooled storage: unable to resolve identity of remote)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets e082c1832e09
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Clone from repo with content should result in shared store being created
 
   $ hg --config share.pool=share clone source1a share-dest1a
   (sharing from new pooled repository b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 1 files
   new changesets b5f04eac9d8f:e5bfe23c0b47
   searching for changes
   no changes found
   adding remote bookmark bookA
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 The shared repo should have been created
 
   $ ls share
   b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1
 
 The destination should point to it
 
   $ cat share-dest1a/.hg/sharedpath; echo
   $TESTTMP/share/b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1/.hg
 
 The destination should have bookmarks
 
   $ hg -R share-dest1a bookmarks
      bookA                     2:e5bfe23c0b47
 
 The default path should be the remote, not the share
 
   $ hg -R share-dest1a config paths.default
   $TESTTMP/source1a
 
 Clone with existing share dir should result in pull + share
 
   $ hg --config share.pool=share clone source1b share-dest1b
   (sharing from existing pooled repository b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
-  added 4 changesets with 4 changes to 1 files (+4 heads)
   adding remote bookmark head1
   adding remote bookmark head2
+  added 4 changesets with 4 changes to 1 files (+4 heads)
   new changesets 4a8dc1ab4c13:6bacf4683960
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ ls share
   b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1
 
   $ cat share-dest1b/.hg/sharedpath; echo
   $TESTTMP/share/b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1/.hg
 
 We only get bookmarks from the remote, not everything in the share
 
   $ hg -R share-dest1b bookmarks
      head1                     3:4a8dc1ab4c13
      head2                     4:99f71071f117
 
 Default path should be source, not share.
 
   $ hg -R share-dest1b config paths.default
   $TESTTMP/source1b
 
 Checked out revision should be head of default branch
 
   $ hg -R share-dest1b log -r .
   changeset:   4:99f71071f117
   bookmark:    head2
   parent:      0:b5f04eac9d8f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     head2
   
 
 Clone from unrelated repo should result in new share
 
   $ hg --config share.pool=share clone source2 share-dest2
   (sharing from new pooled repository 22aeff664783fd44c6d9b435618173c118c3448e)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files
   new changesets 22aeff664783:63cf6c3dba4a
   searching for changes
   no changes found
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ ls share
   22aeff664783fd44c6d9b435618173c118c3448e
   b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1
 
 remote naming mode works as advertised
 
   $ hg --config share.pool=shareremote --config share.poolnaming=remote clone source1a share-remote1a
   (sharing from new pooled repository 195bb1fcdb595c14a6c13e0269129ed78f6debde)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 1 files
   new changesets b5f04eac9d8f:e5bfe23c0b47
   searching for changes
   no changes found
   adding remote bookmark bookA
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ ls shareremote
   195bb1fcdb595c14a6c13e0269129ed78f6debde
 
   $ hg --config share.pool=shareremote --config share.poolnaming=remote clone source1b share-remote1b
   (sharing from new pooled repository c0d4f83847ca2a873741feb7048a45085fd47c46)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 6 changesets with 6 changes to 1 files (+4 heads)
   new changesets b5f04eac9d8f:6bacf4683960
   searching for changes
   no changes found
   adding remote bookmark head1
   adding remote bookmark head2
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ ls shareremote
   195bb1fcdb595c14a6c13e0269129ed78f6debde
   c0d4f83847ca2a873741feb7048a45085fd47c46
 
 request to clone a single revision is respected in sharing mode
 
   $ hg --config share.pool=sharerevs clone -r 4a8dc1ab4c13 source1b share-1arev
   (sharing from new pooled repository b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1)
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files
   new changesets b5f04eac9d8f:4a8dc1ab4c13
   no changes found
   adding remote bookmark head1
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg -R share-1arev log -G
   @  changeset:   1:4a8dc1ab4c13
   |  bookmark:    head1
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     head1
   |
   o  changeset:   0:b5f04eac9d8f
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     initial
   
 
 making another clone should only pull down requested rev
 
   $ hg --config share.pool=sharerevs clone -r 99f71071f117 source1b share-1brev
   (sharing from existing pooled repository b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
-  added 1 changesets with 1 changes to 1 files (+1 heads)
   adding remote bookmark head1
   adding remote bookmark head2
+  added 1 changesets with 1 changes to 1 files (+1 heads)
   new changesets 99f71071f117
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg -R share-1brev log -G
   @  changeset:   2:99f71071f117
   |  bookmark:    head2
   |  tag:         tip
   |  parent:      0:b5f04eac9d8f
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     head2
   |
   | o  changeset:   1:4a8dc1ab4c13
   |/   bookmark:    head1
   |    user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     head1
   |
   o  changeset:   0:b5f04eac9d8f
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     initial
   
 
 Request to clone a single branch is respected in sharing mode
 
   $ hg --config share.pool=sharebranch clone -b branch1 source1b share-1bbranch1
   (sharing from new pooled repository b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1)
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files
   new changesets b5f04eac9d8f:5f92a6c1a1b1
   no changes found
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg -R share-1bbranch1 log -G
   o  changeset:   1:5f92a6c1a1b1
   |  branch:      branch1
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     branch1
   |
   @  changeset:   0:b5f04eac9d8f
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     initial
   
 
   $ hg --config share.pool=sharebranch clone -b branch2 source1b share-1bbranch2
   (sharing from existing pooled repository b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   new changesets 6bacf4683960
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg -R share-1bbranch2 log -G
   o  changeset:   2:6bacf4683960
   |  branch:      branch2
   |  tag:         tip
   |  parent:      0:b5f04eac9d8f
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     branch2
   |
   | o  changeset:   1:5f92a6c1a1b1
   |/   branch:      branch1
   |    user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     branch1
   |
   @  changeset:   0:b5f04eac9d8f
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     initial
   
 
 -U is respected in share clone mode
 
   $ hg --config share.pool=share clone -U source1a share-1anowc
   (sharing from existing pooled repository b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1)
   searching for changes
   no changes found
   adding remote bookmark bookA
 
   $ ls share-1anowc
 
 Test that auto sharing doesn't cause failure of "hg clone local remote"
 
   $ cd $TESTTMP
   $ hg -R a id -r 0
   acb14030fe0a
   $ hg id -R remote -r 0
   abort: repository remote not found!
   [255]
   $ hg --config share.pool=share -q clone -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" a ssh://user@dummy/remote
   $ hg -R remote id -r 0
   acb14030fe0a
 
 Cloning into pooled storage doesn't race (issue5104)
 
   $ HGPOSTLOCKDELAY=2.0 hg --config share.pool=racepool --config extensions.lockdelay=$TESTDIR/lockdelay.py clone source1a share-destrace1 > race1.log 2>&1 &
   $ HGPRELOCKDELAY=1.0 hg --config share.pool=racepool --config extensions.lockdelay=$TESTDIR/lockdelay.py clone source1a share-destrace2  > race2.log 2>&1
   $ wait
 
   $ hg -R share-destrace1 log -r tip
   changeset:   2:e5bfe23c0b47
   bookmark:    bookA
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1a
   
 
   $ hg -R share-destrace2 log -r tip
   changeset:   2:e5bfe23c0b47
   bookmark:    bookA
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1a
   
 One repo should be new, the other should be shared from the pool. We
 don't care which is which, so we just make sure we always print the
 one containing "new pooled" first, then one one containing "existing
 pooled".
 
   $ (grep 'new pooled' race1.log > /dev/null && cat race1.log || cat race2.log) | grep -v lock
   (sharing from new pooled repository b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 1 files
   new changesets b5f04eac9d8f:e5bfe23c0b47
   searching for changes
   no changes found
   adding remote bookmark bookA
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ (grep 'existing pooled' race1.log > /dev/null && cat race1.log || cat race2.log) | grep -v lock
   (sharing from existing pooled repository b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1)
   searching for changes
   no changes found
   adding remote bookmark bookA
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 SEC: check for unsafe ssh url
 
   $ cat >> $HGRCPATH << EOF
   > [ui]
   > ssh = sh -c "read l; read l; read l"
   > EOF
 
   $ hg clone 'ssh://-oProxyCommand=touch${IFS}owned/path'
   abort: potentially unsafe url: 'ssh://-oProxyCommand=touch${IFS}owned/path'
   [255]
   $ hg clone 'ssh://%2DoProxyCommand=touch${IFS}owned/path'
   abort: potentially unsafe url: 'ssh://-oProxyCommand=touch${IFS}owned/path'
   [255]
   $ hg clone 'ssh://fakehost|touch%20owned/path'
   abort: no suitable response from remote hg!
   [255]
   $ hg clone 'ssh://fakehost%7Ctouch%20owned/path'
   abort: no suitable response from remote hg!
   [255]
 
   $ hg clone 'ssh://-oProxyCommand=touch [e-mail]/nonexistent/path'
   abort: potentially unsafe url: 'ssh://-oProxyCommand=touch owned [e-mail]/nonexistent/path'
   [255]
 
 #if windows
   $ hg clone "ssh://%26touch%20owned%20/" --debug
   running sh -c "read l; read l; read l" "&touch owned " "hg -R . serve --stdio"
   sending upgrade request: * proto=exp-ssh-v2-0003 (glob) (sshv2 !)
   sending hello command
   sending between command
   abort: no suitable response from remote hg!
   [255]
   $ hg clone "ssh://example.com:%26touch%20owned%20/" --debug
   running sh -c "read l; read l; read l" -p "&touch owned " example.com "hg -R . serve --stdio"
   sending upgrade request: * proto=exp-ssh-v2-0003 (glob) (sshv2 !)
   sending hello command
   sending between command
   abort: no suitable response from remote hg!
   [255]
 #else
   $ hg clone "ssh://%3btouch%20owned%20/" --debug
   running sh -c "read l; read l; read l" ';touch owned ' 'hg -R . serve --stdio'
   sending upgrade request: * proto=exp-ssh-v2-0003 (glob) (sshv2 !)
   sending hello command
   sending between command
   abort: no suitable response from remote hg!
   [255]
   $ hg clone "ssh://example.com:%3btouch%20owned%20/" --debug
   running sh -c "read l; read l; read l" -p ';touch owned ' example.com 'hg -R . serve --stdio'
   sending upgrade request: * proto=exp-ssh-v2-0003 (glob) (sshv2 !)
   sending hello command
   sending between command
   abort: no suitable response from remote hg!
   [255]
 #endif
 
   $ hg clone "ssh://v-alid.example.com/" --debug
   running sh -c "read l; read l; read l" v-alid\.example\.com ['"]hg -R \. serve --stdio['"] (re)
   sending upgrade request: * proto=exp-ssh-v2-0003 (glob) (sshv2 !)
   sending hello command
   sending between command
   abort: no suitable response from remote hg!
   [255]
 
 We should not have created a file named owned - if it exists, the
 attack succeeded.
   $ if test -f owned; then echo 'you got owned'; fi
 
 Cloning without fsmonitor enabled does not print a warning for small repos
 
   $ hg clone a fsmonitor-default
   updating to bookmark @ on branch stable
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Lower the warning threshold to simulate a large repo
 
   $ cat >> $HGRCPATH << EOF
   > [fsmonitor]
   > warn_update_file_count = 2
   > EOF
 
 We should see a warning about no fsmonitor on supported platforms
 
 #if linuxormacos no-fsmonitor
   $ hg clone a nofsmonitor
   updating to bookmark @ on branch stable
   (warning: large working directory being used without fsmonitor enabled; enable fsmonitor to improve performance; see "hg help -e fsmonitor")
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #else
   $ hg clone a nofsmonitor
   updating to bookmark @ on branch stable
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #endif
 
 We should not see warning about fsmonitor when it is enabled
 
 #if fsmonitor
   $ hg clone a fsmonitor-enabled
   updating to bookmark @ on branch stable
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #endif
 
 We can disable the fsmonitor warning
 
   $ hg --config fsmonitor.warn_when_unused=false clone a fsmonitor-disable-warning
   updating to bookmark @ on branch stable
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Loaded fsmonitor but disabled in config should still print warning
 
 #if linuxormacos fsmonitor
   $ hg --config fsmonitor.mode=off clone a fsmonitor-mode-off
   updating to bookmark @ on branch stable
   (warning: large working directory being used without fsmonitor enabled; enable fsmonitor to improve performance; see "hg help -e fsmonitor") (fsmonitor !)
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #endif
 
 Warning not printed if working directory isn't empty
 
   $ hg -q clone a fsmonitor-update
   (warning: large working directory being used without fsmonitor enabled; enable fsmonitor to improve performance; see "hg help -e fsmonitor") (?)
   $ cd fsmonitor-update
   $ hg up acb14030fe0a
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   (leaving bookmark @)
   $ hg up cf0fe1914066
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 `hg update` from null revision also prints
 
   $ hg up null
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
 
 #if linuxormacos no-fsmonitor
   $ hg up cf0fe1914066
   (warning: large working directory being used without fsmonitor enabled; enable fsmonitor to improve performance; see "hg help -e fsmonitor")
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #else
   $ hg up cf0fe1914066
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #endif
 
   $ cd ..
 

tests/test-eol-hook.t

@@ -1,218 +1,211 b''
 Test the EOL hook
 
   $ hg init main
   $ cat > main/.hg/hgrc <<EOF
   > [hooks]
   > pretxnchangegroup = python:hgext.eol.hook
   > EOF
   $ hg clone main fork
   updating to branch default
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd fork
 
 Create repo
   $ cat > .hgeol <<EOF
   > [patterns]
   > mixed.txt = BIN
   > crlf.txt = CRLF
   > **.txt = native
   > EOF
   $ hg add .hgeol
   $ hg commit -m 'Commit .hgeol'
 
   $ printf "first\nsecond\nthird\n" > a.txt
   $ hg add a.txt
   $ hg commit -m 'LF a.txt'
   $ hg push ../main
   pushing to ../main
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
 
   $ printf "first\r\nsecond\r\nthird\n" > a.txt
   $ hg commit -m 'CRLF a.txt'
   $ hg push ../main
   pushing to ../main
   searching for changes
   adding changesets
   adding manifests
   adding file changes
-  added 1 changesets with 1 changes to 1 files
   error: pretxnchangegroup hook failed: end-of-line check failed:
     a.txt in a8ee6548cd86 should not have CRLF line endings
   transaction abort!
   rollback completed
   abort: end-of-line check failed:
     a.txt in a8ee6548cd86 should not have CRLF line endings
   [255]
 
   $ printf "first\nsecond\nthird\n" > a.txt
   $ hg commit -m 'LF a.txt (fixed)'
   $ hg push ../main
   pushing to ../main
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files
 
   $ printf "first\nsecond\nthird\n" > crlf.txt
   $ hg add crlf.txt
   $ hg commit -m 'LF crlf.txt'
   $ hg push ../main
   pushing to ../main
   searching for changes
   adding changesets
   adding manifests
   adding file changes
-  added 1 changesets with 1 changes to 1 files
   error: pretxnchangegroup hook failed: end-of-line check failed:
     crlf.txt in 004ba2132725 should not have LF line endings
   transaction abort!
   rollback completed
   abort: end-of-line check failed:
     crlf.txt in 004ba2132725 should not have LF line endings
   [255]
 
   $ printf "first\r\nsecond\r\nthird\r\n" > crlf.txt
   $ hg commit -m 'CRLF crlf.txt (fixed)'
   $ hg push ../main
   pushing to ../main
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files
 
   $ printf "first\r\nsecond" > b.txt
   $ hg add b.txt
   $ hg commit -m 'CRLF b.txt'
   $ hg push ../main
   pushing to ../main
   searching for changes
   adding changesets
   adding manifests
   adding file changes
-  added 1 changesets with 1 changes to 1 files
   error: pretxnchangegroup hook failed: end-of-line check failed:
     b.txt in fbcf9b1025f5 should not have CRLF line endings
   transaction abort!
   rollback completed
   abort: end-of-line check failed:
     b.txt in fbcf9b1025f5 should not have CRLF line endings
   [255]
 
   $ hg up -r -2
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ printf "some\nother\nfile" > c.txt
   $ hg add c.txt
   $ hg commit -m "LF c.txt, b.txt doesn't exist here"
   created new head
   $ hg push -f ../main
   pushing to ../main
   searching for changes
   adding changesets
   adding manifests
   adding file changes
-  added 2 changesets with 2 changes to 2 files (+1 heads)
   error: pretxnchangegroup hook failed: end-of-line check failed:
     b.txt in fbcf9b1025f5 should not have CRLF line endings
   transaction abort!
   rollback completed
   abort: end-of-line check failed:
     b.txt in fbcf9b1025f5 should not have CRLF line endings
   [255]
 
 Test checkheadshook alias
 
   $ cat > ../main/.hg/hgrc <<EOF
   > [hooks]
   > pretxnchangegroup = python:hgext.eol.checkheadshook
   > EOF
   $ hg push -f ../main
   pushing to ../main
   searching for changes
   adding changesets
   adding manifests
   adding file changes
-  added 2 changesets with 2 changes to 2 files (+1 heads)
   error: pretxnchangegroup hook failed: end-of-line check failed:
     b.txt in fbcf9b1025f5 should not have CRLF line endings
   transaction abort!
   rollback completed
   abort: end-of-line check failed:
     b.txt in fbcf9b1025f5 should not have CRLF line endings
   [255]
 
 We can fix the head and push again
 
   $ hg up 6
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ printf "first\nsecond" > b.txt
   $ hg ci -m "remove CRLF from b.txt"
   $ hg push -f ../main
   pushing to ../main
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 2 files (+1 heads)
   $ hg -R ../main rollback
   repository tip rolled back to revision 5 (undo push)
 
 Test it still fails with checkallhook
 
   $ cat > ../main/.hg/hgrc <<EOF
   > [hooks]
   > pretxnchangegroup = python:hgext.eol.checkallhook
   > EOF
   $ hg push -f ../main
   pushing to ../main
   searching for changes
   adding changesets
   adding manifests
   adding file changes
-  added 3 changesets with 3 changes to 2 files (+1 heads)
   error: pretxnchangegroup hook failed: end-of-line check failed:
     b.txt in fbcf9b1025f5 should not have CRLF line endings
   transaction abort!
   rollback completed
   abort: end-of-line check failed:
     b.txt in fbcf9b1025f5 should not have CRLF line endings
   [255]
 
 But we can push the clean head
 
   $ hg push -r7 -f ../main
   pushing to ../main
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 Test multiple files/revisions output
 
   $ printf "another\r\nbad\r\none" > d.txt
   $ hg add d.txt
   $ hg ci -m "add d.txt"
   $ hg push -f ../main
   pushing to ../main
   searching for changes
   adding changesets
   adding manifests
   adding file changes
-  added 3 changesets with 3 changes to 2 files (+1 heads)
   error: pretxnchangegroup hook failed: end-of-line check failed:
     b.txt in fbcf9b1025f5 should not have CRLF line endings
     d.txt in a7040e68714f should not have CRLF line endings
   transaction abort!
   rollback completed
   abort: end-of-line check failed:
     b.txt in fbcf9b1025f5 should not have CRLF line endings
     d.txt in a7040e68714f should not have CRLF line endings
   [255]
 
   $ cd ..