branching: merge stable into default

contrib/perf.py

@@ -1,4449 +1,4569 b''
 # perf.py - performance test routines
 '''helper extension to measure performance
 
 Configurations
 ==============
 
 ``perf``
 --------
 
 ``all-timing``
     When set, additional statistics will be reported for each benchmark: best,
     worst, median average. If not set only the best timing is reported
     (default: off).
 
 ``presleep``
   number of second to wait before any group of runs (default: 1)
 
 ``pre-run``
   number of run to perform before starting measurement.
 
 ``profile-benchmark``
   Enable profiling for the benchmarked section.
   (The first iteration is benchmarked)
 
 ``run-limits``
   Control the number of runs each benchmark will perform. The option value
   should be a list of `<time>-<numberofrun>` pairs. After each run the
   conditions are considered in order with the following logic:
 
       If benchmark has been running for <time> seconds, and we have performed
       <numberofrun> iterations, stop the benchmark,
 
   The default value is: `3.0-100, 10.0-3`
 
 ``stub``
     When set, benchmarks will only be run once, useful for testing
     (default: off)
 '''
 
 # "historical portability" policy of perf.py:
 #
 # We have to do:
 # - make perf.py "loadable" with as wide Mercurial version as possible
 #   This doesn't mean that perf commands work correctly with that Mercurial.
 #   BTW, perf.py itself has been available since 1.1 (or eb240755386d).
 # - make historical perf command work correctly with as wide Mercurial
 #   version as possible
 #
 # We have to do, if possible with reasonable cost:
 # - make recent perf command for historical feature work correctly
 #   with early Mercurial
 #
 # We don't have to do:
 # - make perf command for recent feature work correctly with early
 #   Mercurial
 
 import contextlib
 import functools
 import gc
 import os
 import random
 import shutil
 import struct
 import sys
 import tempfile
 import threading
 import time
 
 import mercurial.revlog
 from mercurial import (
     changegroup,
     cmdutil,
     commands,
     copies,
     error,
     extensions,
     hg,
     mdiff,
     merge,
     util,
 )
 
 # for "historical portability":
 # try to import modules separately (in dict order), and ignore
 # failure, because these aren't available with early Mercurial
 try:
     from mercurial import branchmap  # since 2.5 (or bcee63733aad)
 except ImportError:
     pass
 try:
     from mercurial import obsolete  # since 2.3 (or ad0d6c2b3279)
 except ImportError:
     pass
 try:
     from mercurial import registrar  # since 3.7 (or 37d50250b696)
 
     dir(registrar)  # forcibly load it
 except ImportError:
     registrar = None
 try:
     from mercurial import repoview  # since 2.5 (or 3a6ddacb7198)
 except ImportError:
     pass
 try:
     from mercurial.utils import repoviewutil  # since 5.0
 except ImportError:
     repoviewutil = None
 try:
     from mercurial import scmutil  # since 1.9 (or 8b252e826c68)
 except ImportError:
     pass
 try:
     from mercurial import setdiscovery  # since 1.9 (or cb98fed52495)
 except ImportError:
     pass
 
 try:
     from mercurial import profiling
 except ImportError:
     profiling = None
 
 try:
     from mercurial.revlogutils import constants as revlog_constants
 
     perf_rl_kind = (revlog_constants.KIND_OTHER, b'created-by-perf')
 
     def revlog(opener, *args, **kwargs):
         return mercurial.revlog.revlog(opener, perf_rl_kind, *args, **kwargs)
 
 
 except (ImportError, AttributeError):
     perf_rl_kind = None
 
     def revlog(opener, *args, **kwargs):
         return mercurial.revlog.revlog(opener, *args, **kwargs)
 
 
 def identity(a):
     return a
 
 
 try:
     from mercurial import pycompat
 
     getargspec = pycompat.getargspec  # added to module after 4.5
     _byteskwargs = pycompat.byteskwargs  # since 4.1 (or fbc3f73dc802)
     _sysstr = pycompat.sysstr  # since 4.0 (or 2219f4f82ede)
     _bytestr = pycompat.bytestr  # since 4.2 (or b70407bd84d5)
     _xrange = pycompat.xrange  # since 4.8 (or 7eba8f83129b)
     fsencode = pycompat.fsencode  # since 3.9 (or f4a5e0e86a7e)
     if pycompat.ispy3:
         _maxint = sys.maxsize  # per py3 docs for replacing maxint
     else:
         _maxint = sys.maxint
 except (NameError, ImportError, AttributeError):
     import inspect
 
     getargspec = inspect.getargspec
     _byteskwargs = identity
     _bytestr = str
     fsencode = identity  # no py3 support
     _maxint = sys.maxint  # no py3 support
     _sysstr = lambda x: x  # no py3 support
     _xrange = xrange
 
 try:
     # 4.7+
     queue = pycompat.queue.Queue
 except (NameError, AttributeError, ImportError):
     # <4.7.
     try:
         queue = pycompat.queue
     except (NameError, AttributeError, ImportError):
         import Queue as queue
 
 try:
     from mercurial import logcmdutil
 
     makelogtemplater = logcmdutil.maketemplater
 except (AttributeError, ImportError):
     try:
         makelogtemplater = cmdutil.makelogtemplater
     except (AttributeError, ImportError):
         makelogtemplater = None
 
 # for "historical portability":
 # define util.safehasattr forcibly, because util.safehasattr has been
 # available since 1.9.3 (or 94b200a11cf7)
 _undefined = object()
 
 
 def safehasattr(thing, attr):
     return getattr(thing, _sysstr(attr), _undefined) is not _undefined
 
 
 setattr(util, 'safehasattr', safehasattr)
 
 # for "historical portability":
 # define util.timer forcibly, because util.timer has been available
 # since ae5d60bb70c9
 if safehasattr(time, 'perf_counter'):
     util.timer = time.perf_counter
 elif os.name == b'nt':
     util.timer = time.clock
 else:
     util.timer = time.time
 
 # for "historical portability":
 # use locally defined empty option list, if formatteropts isn't
 # available, because commands.formatteropts has been available since
 # 3.2 (or 7a7eed5176a4), even though formatting itself has been
 # available since 2.2 (or ae5f92e154d3)
 formatteropts = getattr(
     cmdutil, "formatteropts", getattr(commands, "formatteropts", [])
 )
 
 # for "historical portability":
 # use locally defined option list, if debugrevlogopts isn't available,
 # because commands.debugrevlogopts has been available since 3.7 (or
 # 5606f7d0d063), even though cmdutil.openrevlog() has been available
 # since 1.9 (or a79fea6b3e77).
 revlogopts = getattr(
     cmdutil,
     "debugrevlogopts",
     getattr(
         commands,
         "debugrevlogopts",
         [
             (b'c', b'changelog', False, b'open changelog'),
             (b'm', b'manifest', False, b'open manifest'),
             (b'', b'dir', False, b'open directory manifest'),
         ],
     ),
 )
 
 cmdtable = {}
 
 
 # for "historical portability":
 # define parsealiases locally, because cmdutil.parsealiases has been
 # available since 1.5 (or 6252852b4332)
 def parsealiases(cmd):
     return cmd.split(b"|")
 
 
 if safehasattr(registrar, 'command'):
     command = registrar.command(cmdtable)
 elif safehasattr(cmdutil, 'command'):
     command = cmdutil.command(cmdtable)
     if 'norepo' not in getargspec(command).args:
         # for "historical portability":
         # wrap original cmdutil.command, because "norepo" option has
         # been available since 3.1 (or 75a96326cecb)
         _command = command
 
         def command(name, options=(), synopsis=None, norepo=False):
             if norepo:
                 commands.norepo += b' %s' % b' '.join(parsealiases(name))
             return _command(name, list(options), synopsis)
 
 
 else:
     # for "historical portability":
     # define "@command" annotation locally, because cmdutil.command
     # has been available since 1.9 (or 2daa5179e73f)
     def command(name, options=(), synopsis=None, norepo=False):
         def decorator(func):
             if synopsis:
                 cmdtable[name] = func, list(options), synopsis
             else:
                 cmdtable[name] = func, list(options)
             if norepo:
                 commands.norepo += b' %s' % b' '.join(parsealiases(name))
             return func
 
         return decorator
 
 
 try:
     import mercurial.registrar
     import mercurial.configitems
 
     configtable = {}
     configitem = mercurial.registrar.configitem(configtable)
     configitem(
         b'perf',
         b'presleep',
         default=mercurial.configitems.dynamicdefault,
         experimental=True,
     )
     configitem(
         b'perf',
         b'stub',
         default=mercurial.configitems.dynamicdefault,
         experimental=True,
     )
     configitem(
         b'perf',
         b'parentscount',
         default=mercurial.configitems.dynamicdefault,
         experimental=True,
     )
     configitem(
         b'perf',
         b'all-timing',
         default=mercurial.configitems.dynamicdefault,
         experimental=True,
     )
     configitem(
         b'perf',
         b'pre-run',
         default=mercurial.configitems.dynamicdefault,
     )
     configitem(
         b'perf',
         b'profile-benchmark',
         default=mercurial.configitems.dynamicdefault,
     )
     configitem(
         b'perf',
         b'run-limits',
         default=mercurial.configitems.dynamicdefault,
         experimental=True,
     )
 except (ImportError, AttributeError):
     pass
 except TypeError:
     # compatibility fix for a11fd395e83f
     # hg version: 5.2
     configitem(
         b'perf',
         b'presleep',
         default=mercurial.configitems.dynamicdefault,
     )
     configitem(
         b'perf',
         b'stub',
         default=mercurial.configitems.dynamicdefault,
     )
     configitem(
         b'perf',
         b'parentscount',
         default=mercurial.configitems.dynamicdefault,
     )
     configitem(
         b'perf',
         b'all-timing',
         default=mercurial.configitems.dynamicdefault,
     )
     configitem(
         b'perf',
         b'pre-run',
         default=mercurial.configitems.dynamicdefault,
     )
     configitem(
         b'perf',
         b'profile-benchmark',
         default=mercurial.configitems.dynamicdefault,
     )
     configitem(
         b'perf',
         b'run-limits',
         default=mercurial.configitems.dynamicdefault,
     )
 
 
 def getlen(ui):
     if ui.configbool(b"perf", b"stub", False):
         return lambda x: 1
     return len
 
 
 class noop:
     """dummy context manager"""
 
     def __enter__(self):
         pass
 
     def __exit__(self, *args):
         pass
 
 
 NOOPCTX = noop()
 
 
 def gettimer(ui, opts=None):
     """return a timer function and formatter: (timer, formatter)
 
     This function exists to gather the creation of formatter in a single
     place instead of duplicating it in all performance commands."""
 
     # enforce an idle period before execution to counteract power management
     # experimental config: perf.presleep
     time.sleep(getint(ui, b"perf", b"presleep", 1))
 
     if opts is None:
         opts = {}
     # redirect all to stderr unless buffer api is in use
     if not ui._buffers:
         ui = ui.copy()
         uifout = safeattrsetter(ui, b'fout', ignoremissing=True)
         if uifout:
             # for "historical portability":
             # ui.fout/ferr have been available since 1.9 (or 4e1ccd4c2b6d)
             uifout.set(ui.ferr)
 
     # get a formatter
     uiformatter = getattr(ui, 'formatter', None)
     if uiformatter:
         fm = uiformatter(b'perf', opts)
     else:
         # for "historical portability":
         # define formatter locally, because ui.formatter has been
         # available since 2.2 (or ae5f92e154d3)
         from mercurial import node
 
         class defaultformatter:
             """Minimized composition of baseformatter and plainformatter"""
 
             def __init__(self, ui, topic, opts):
                 self._ui = ui
                 if ui.debugflag:
                     self.hexfunc = node.hex
                 else:
                     self.hexfunc = node.short
 
             def __nonzero__(self):
                 return False
 
             __bool__ = __nonzero__
 
             def startitem(self):
                 pass
 
             def data(self, **data):
                 pass
 
             def write(self, fields, deftext, *fielddata, **opts):
                 self._ui.write(deftext % fielddata, **opts)
 
             def condwrite(self, cond, fields, deftext, *fielddata, **opts):
                 if cond:
                     self._ui.write(deftext % fielddata, **opts)
 
             def plain(self, text, **opts):
                 self._ui.write(text, **opts)
 
             def end(self):
                 pass
 
         fm = defaultformatter(ui, b'perf', opts)
 
     # stub function, runs code only once instead of in a loop
     # experimental config: perf.stub
     if ui.configbool(b"perf", b"stub", False):
         return functools.partial(stub_timer, fm), fm
 
     # experimental config: perf.all-timing
     displayall = ui.configbool(b"perf", b"all-timing", True)
 
     # experimental config: perf.run-limits
     limitspec = ui.configlist(b"perf", b"run-limits", [])
     limits = []
     for item in limitspec:
         parts = item.split(b'-', 1)
         if len(parts) < 2:
             ui.warn((b'malformatted run limit entry, missing "-": %s\n' % item))
             continue
         try:
             time_limit = float(_sysstr(parts[0]))
         except ValueError as e:
             ui.warn(
                 (
                     b'malformatted run limit entry, %s: %s\n'
                     % (_bytestr(e), item)
                 )
             )
             continue
         try:
             run_limit = int(_sysstr(parts[1]))
         except ValueError as e:
             ui.warn(
                 (
                     b'malformatted run limit entry, %s: %s\n'
                     % (_bytestr(e), item)
                 )
             )
             continue
         limits.append((time_limit, run_limit))
     if not limits:
         limits = DEFAULTLIMITS
 
     profiler = None
     if profiling is not None:
         if ui.configbool(b"perf", b"profile-benchmark", False):
             profiler = profiling.profile(ui)
 
     prerun = getint(ui, b"perf", b"pre-run", 0)
     t = functools.partial(
         _timer,
         fm,
         displayall=displayall,
         limits=limits,
         prerun=prerun,
         profiler=profiler,
     )
     return t, fm
 
 
 def stub_timer(fm, func, setup=None, title=None):
     if setup is not None:
         setup()
     func()
 
 
 @contextlib.contextmanager
 def timeone():
     r = []
     ostart = os.times()
     cstart = util.timer()
     yield r
     cstop = util.timer()
     ostop = os.times()
     a, b = ostart, ostop
     r.append((cstop - cstart, b[0] - a[0], b[1] - a[1]))
 
 
 # list of stop condition (elapsed time, minimal run count)
 DEFAULTLIMITS = (
     (3.0, 100),
     (10.0, 3),
 )
 
 
 @contextlib.contextmanager
 def noop_context():
     yield
 
 
 def _timer(
     fm,
     func,
     setup=None,
     context=noop_context,
     title=None,
     displayall=False,
     limits=DEFAULTLIMITS,
     prerun=0,
     profiler=None,
 ):
     gc.collect()
     results = []
     begin = util.timer()
     count = 0
     if profiler is None:
         profiler = NOOPCTX
     for i in range(prerun):
         if setup is not None:
             setup()
         with context():
             func()
     keepgoing = True
     while keepgoing:
         if setup is not None:
             setup()
         with context():
             with profiler:
                 with timeone() as item:
                     r = func()
         profiler = NOOPCTX
         count += 1
         results.append(item[0])
         cstop = util.timer()
         # Look for a stop condition.
         elapsed = cstop - begin
         for t, mincount in limits:
             if elapsed >= t and count >= mincount:
                 keepgoing = False
                 break
 
     formatone(fm, results, title=title, result=r, displayall=displayall)
 
 
 def formatone(fm, timings, title=None, result=None, displayall=False):
     count = len(timings)
 
     fm.startitem()
 
     if title:
         fm.write(b'title', b'! %s\n', title)
     if result:
         fm.write(b'result', b'! result: %s\n', result)
 
     def display(role, entry):
         prefix = b''
         if role != b'best':
             prefix = b'%s.' % role
         fm.plain(b'!')
         fm.write(prefix + b'wall', b' wall %f', entry[0])
         fm.write(prefix + b'comb', b' comb %f', entry[1] + entry[2])
         fm.write(prefix + b'user', b' user %f', entry[1])
         fm.write(prefix + b'sys', b' sys %f', entry[2])
         fm.write(prefix + b'count', b' (%s of %%d)' % role, count)
         fm.plain(b'\n')
 
     timings.sort()
     min_val = timings[0]
     display(b'best', min_val)
     if displayall:
         max_val = timings[-1]
         display(b'max', max_val)
         avg = tuple([sum(x) / count for x in zip(*timings)])
         display(b'avg', avg)
         median = timings[len(timings) // 2]
         display(b'median', median)
 
 
 # utilities for historical portability
 
 
 def getint(ui, section, name, default):
     # for "historical portability":
     # ui.configint has been available since 1.9 (or fa2b596db182)
     v = ui.config(section, name, None)
     if v is None:
         return default
     try:
         return int(v)
     except ValueError:
         raise error.ConfigError(
             b"%s.%s is not an integer ('%s')" % (section, name, v)
         )
 
 
 def safeattrsetter(obj, name, ignoremissing=False):
     """Ensure that 'obj' has 'name' attribute before subsequent setattr
 
     This function is aborted, if 'obj' doesn't have 'name' attribute
     at runtime. This avoids overlooking removal of an attribute, which
     breaks assumption of performance measurement, in the future.
 
     This function returns the object to (1) assign a new value, and
     (2) restore an original value to the attribute.
 
     If 'ignoremissing' is true, missing 'name' attribute doesn't cause
     abortion, and this function returns None. This is useful to
     examine an attribute, which isn't ensured in all Mercurial
     versions.
     """
     if not util.safehasattr(obj, name):
         if ignoremissing:
             return None
         raise error.Abort(
             (
                 b"missing attribute %s of %s might break assumption"
                 b" of performance measurement"
             )
             % (name, obj)
         )
 
     origvalue = getattr(obj, _sysstr(name))
 
     class attrutil:
         def set(self, newvalue):
             setattr(obj, _sysstr(name), newvalue)
 
         def restore(self):
             setattr(obj, _sysstr(name), origvalue)
 
     return attrutil()
 
 
 # utilities to examine each internal API changes
 
 
 def getbranchmapsubsettable():
     # for "historical portability":
     # subsettable is defined in:
     # - branchmap since 2.9 (or 175c6fd8cacc)
     # - repoview since 2.5 (or 59a9f18d4587)
     # - repoviewutil since 5.0
     for mod in (branchmap, repoview, repoviewutil):
         subsettable = getattr(mod, 'subsettable', None)
         if subsettable:
             return subsettable
 
     # bisecting in bcee63733aad::59a9f18d4587 can reach here (both
     # branchmap and repoview modules exist, but subsettable attribute
     # doesn't)
     raise error.Abort(
         b"perfbranchmap not available with this Mercurial",
         hint=b"use 2.5 or later",
     )
 
 
 def getsvfs(repo):
     """Return appropriate object to access files under .hg/store"""
     # for "historical portability":
     # repo.svfs has been available since 2.3 (or 7034365089bf)
     svfs = getattr(repo, 'svfs', None)
     if svfs:
         return svfs
     else:
         return getattr(repo, 'sopener')
 
 
 def getvfs(repo):
     """Return appropriate object to access files under .hg"""
     # for "historical portability":
     # repo.vfs has been available since 2.3 (or 7034365089bf)
     vfs = getattr(repo, 'vfs', None)
     if vfs:
         return vfs
     else:
         return getattr(repo, 'opener')
 
 
 def repocleartagscachefunc(repo):
     """Return the function to clear tags cache according to repo internal API"""
     if util.safehasattr(repo, b'_tagscache'):  # since 2.0 (or 9dca7653b525)
         # in this case, setattr(repo, '_tagscache', None) or so isn't
         # correct way to clear tags cache, because existing code paths
         # expect _tagscache to be a structured object.
         def clearcache():
             # _tagscache has been filteredpropertycache since 2.5 (or
             # 98c867ac1330), and delattr() can't work in such case
             if '_tagscache' in vars(repo):
                 del repo.__dict__['_tagscache']
 
         return clearcache
 
     repotags = safeattrsetter(repo, b'_tags', ignoremissing=True)
     if repotags:  # since 1.4 (or 5614a628d173)
         return lambda: repotags.set(None)
 
     repotagscache = safeattrsetter(repo, b'tagscache', ignoremissing=True)
     if repotagscache:  # since 0.6 (or d7df759d0e97)
         return lambda: repotagscache.set(None)
 
     # Mercurial earlier than 0.6 (or d7df759d0e97) logically reaches
     # this point, but it isn't so problematic, because:
     # - repo.tags of such Mercurial isn't "callable", and repo.tags()
     #   in perftags() causes failure soon
     # - perf.py itself has been available since 1.1 (or eb240755386d)
     raise error.Abort(b"tags API of this hg command is unknown")
 
 
 # utilities to clear cache
 
 
 def clearfilecache(obj, attrname):
     unfiltered = getattr(obj, 'unfiltered', None)
     if unfiltered is not None:
         obj = obj.unfiltered()
     if attrname in vars(obj):
         delattr(obj, attrname)
     obj._filecache.pop(attrname, None)
 
 
 def clearchangelog(repo):
     if repo is not repo.unfiltered():
         object.__setattr__(repo, '_clcachekey', None)
         object.__setattr__(repo, '_clcache', None)
     clearfilecache(repo.unfiltered(), 'changelog')
 
 
 # perf commands
 
 
 @command(b'perf::walk|perfwalk', formatteropts)
 def perfwalk(ui, repo, *pats, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     m = scmutil.match(repo[None], pats, {})
     timer(
         lambda: len(
             list(
                 repo.dirstate.walk(m, subrepos=[], unknown=True, ignored=False)
             )
         )
     )
     fm.end()
 
 
 @command(b'perf::annotate|perfannotate', formatteropts)
 def perfannotate(ui, repo, f, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     fc = repo[b'.'][f]
     timer(lambda: len(fc.annotate(True)))
     fm.end()
 
 
 @command(
     b'perf::status|perfstatus',
     [
         (b'u', b'unknown', False, b'ask status to look for unknown files'),
         (b'', b'dirstate', False, b'benchmark the internal dirstate call'),
     ]
     + formatteropts,
 )
 def perfstatus(ui, repo, **opts):
     """benchmark the performance of a single status call
 
     The repository data are preserved between each call.
 
     By default, only the status of the tracked file are requested. If
     `--unknown` is passed, the "unknown" files are also tracked.
     """
     opts = _byteskwargs(opts)
     # m = match.always(repo.root, repo.getcwd())
     # timer(lambda: sum(map(len, repo.dirstate.status(m, [], False, False,
     #                                                False))))
     timer, fm = gettimer(ui, opts)
     if opts[b'dirstate']:
         dirstate = repo.dirstate
         m = scmutil.matchall(repo)
         unknown = opts[b'unknown']
 
         def status_dirstate():
             s = dirstate.status(
                 m, subrepos=[], ignored=False, clean=False, unknown=unknown
             )
             sum(map(bool, s))
 
         if util.safehasattr(dirstate, 'running_status'):
             with dirstate.running_status(repo):
                 timer(status_dirstate)
                 dirstate.invalidate()
         else:
             timer(status_dirstate)
     else:
         timer(lambda: sum(map(len, repo.status(unknown=opts[b'unknown']))))
     fm.end()
 
 
 @command(b'perf::addremove|perfaddremove', formatteropts)
 def perfaddremove(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     try:
         oldquiet = repo.ui.quiet
         repo.ui.quiet = True
         matcher = scmutil.match(repo[None])
         opts[b'dry_run'] = True
         if 'uipathfn' in getargspec(scmutil.addremove).args:
             uipathfn = scmutil.getuipathfn(repo)
             timer(lambda: scmutil.addremove(repo, matcher, b"", uipathfn, opts))
         else:
             timer(lambda: scmutil.addremove(repo, matcher, b"", opts))
     finally:
         repo.ui.quiet = oldquiet
         fm.end()
 
 
 def clearcaches(cl):
     # behave somewhat consistently across internal API changes
     if util.safehasattr(cl, b'clearcaches'):
         cl.clearcaches()
     elif util.safehasattr(cl, b'_nodecache'):
         # <= hg-5.2
         from mercurial.node import nullid, nullrev
 
         cl._nodecache = {nullid: nullrev}
         cl._nodepos = None
 
 
 @command(b'perf::heads|perfheads', formatteropts)
 def perfheads(ui, repo, **opts):
     """benchmark the computation of a changelog heads"""
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     cl = repo.changelog
 
     def s():
         clearcaches(cl)
 
     def d():
         len(cl.headrevs())
 
     timer(d, setup=s)
     fm.end()
 
 
+def _default_clear_on_disk_tags_cache(repo):
+    from mercurial import tags
+
+    repo.cachevfs.tryunlink(tags._filename(repo))
+
+
+def _default_clear_on_disk_tags_fnodes_cache(repo):
+    from mercurial import tags
+
+    repo.cachevfs.tryunlink(tags._fnodescachefile)
+
+
+def _default_forget_fnodes(repo, revs):
+    """function used by the perf extension to prune some entries from the
+    fnodes cache"""
+    from mercurial import tags
+
+    missing_1 = b'\xff' * 4
+    missing_2 = b'\xff' * 20
+    cache = tags.hgtagsfnodescache(repo.unfiltered())
+    for r in revs:
+        cache._writeentry(r * tags._fnodesrecsize, missing_1, missing_2)
+    cache.write()
+
+
 @command(
     b'perf::tags|perftags',
     formatteropts
     + [
         (b'', b'clear-revlogs', False, b'refresh changelog and manifest'),
+        (
+            b'',
+            b'clear-on-disk-cache',
+            False,
+            b'clear on disk tags cache (DESTRUCTIVE)',
+        ),
+        (
+            b'',
+            b'clear-fnode-cache-all',
+            False,
+            b'clear on disk file node cache (DESTRUCTIVE),',
+        ),
+        (
+            b'',
+            b'clear-fnode-cache-rev',
+            [],
+            b'clear on disk file node cache (DESTRUCTIVE),',
+            b'REVS',
+        ),
+        (
+            b'',
+            b'update-last',
+            b'',
+            b'simulate an update over the last N revisions (DESTRUCTIVE),',
+            b'N',
+        ),
     ],
 )
 def perftags(ui, repo, **opts):
+    """Benchmark tags retrieval in various situation
+
+    The option marked as (DESTRUCTIVE) will alter the on-disk cache, possibly
+    altering performance after the command was run. However, it does not
+    destroy any stored data.
+    """
+    from mercurial import tags
+
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     repocleartagscache = repocleartagscachefunc(repo)
     clearrevlogs = opts[b'clear_revlogs']
+    clear_disk = opts[b'clear_on_disk_cache']
+    clear_fnode = opts[b'clear_fnode_cache_all']
+
+    clear_fnode_revs = opts[b'clear_fnode_cache_rev']
+    update_last_str = opts[b'update_last']
+    update_last = None
+    if update_last_str:
+        try:
+            update_last = int(update_last_str)
+        except ValueError:
+            msg = b'could not parse value for update-last: "%s"'
+            msg %= update_last_str
+            hint = b'value should be an integer'
+            raise error.Abort(msg, hint=hint)
+
+    clear_disk_fn = getattr(
+        tags,
+        "clear_cache_on_disk",
+        _default_clear_on_disk_tags_cache,
+    )
+    clear_fnodes_fn = getattr(
+        tags,
+        "clear_cache_fnodes",
+        _default_clear_on_disk_tags_fnodes_cache,
+    )
+    clear_fnodes_rev_fn = getattr(
+        tags,
+        "forget_fnodes",
+        _default_forget_fnodes,
+    )
+
+    clear_revs = []
+    if clear_fnode_revs:
+        clear_revs.extends(scmutil.revrange(repo, clear_fnode_revs))
+
+    if update_last:
+        revset = b'last(all(), %d)' % update_last
+        last_revs = repo.unfiltered().revs(revset)
+        clear_revs.extend(last_revs)
+
+        from mercurial import repoview
+
+        rev_filter = {(b'experimental', b'extra-filter-revs'): revset}
+        with repo.ui.configoverride(rev_filter, source=b"perf"):
+            filter_id = repoview.extrafilter(repo.ui)
+
+        filter_name = b'%s%%%s' % (repo.filtername, filter_id)
+        pre_repo = repo.filtered(filter_name)
+        pre_repo.tags()  # warm the cache
+        old_tags_path = repo.cachevfs.join(tags._filename(pre_repo))
+        new_tags_path = repo.cachevfs.join(tags._filename(repo))
+
+    clear_revs = sorted(set(clear_revs))
 
     def s():
+        if update_last:
+            util.copyfile(old_tags_path, new_tags_path)
         if clearrevlogs:
             clearchangelog(repo)
             clearfilecache(repo.unfiltered(), 'manifest')
+        if clear_disk:
+            clear_disk_fn(repo)
+        if clear_fnode:
+            clear_fnodes_fn(repo)
+        elif clear_revs:
+            clear_fnodes_rev_fn(repo, clear_revs)
         repocleartagscache()
 
     def t():
         len(repo.tags())
 
     timer(t, setup=s)
     fm.end()
 
 
 @command(b'perf::ancestors|perfancestors', formatteropts)
 def perfancestors(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     heads = repo.changelog.headrevs()
 
     def d():
         for a in repo.changelog.ancestors(heads):
             pass
 
     timer(d)
     fm.end()
 
 
 @command(b'perf::ancestorset|perfancestorset', formatteropts)
 def perfancestorset(ui, repo, revset, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     revs = repo.revs(revset)
     heads = repo.changelog.headrevs()
 
     def d():
         s = repo.changelog.ancestors(heads)
         for rev in revs:
             rev in s
 
     timer(d)
     fm.end()
 
 
 @command(
     b'perf::delta-find',
     revlogopts + formatteropts,
     b'-c|-m|FILE REV',
 )
 def perf_delta_find(ui, repo, arg_1, arg_2=None, **opts):
     """benchmark the process of finding a valid delta for a revlog revision
 
     When a revlog receives a new revision (e.g. from a commit, or from an
     incoming bundle), it searches for a suitable delta-base to produce a delta.
     This perf command measures how much time we spend in this process. It
     operates on an already stored revision.
 
     See `hg help debug-delta-find` for another related command.
     """
     from mercurial import revlogutils
     import mercurial.revlogutils.deltas as deltautil
 
     opts = _byteskwargs(opts)
     if arg_2 is None:
         file_ = None
         rev = arg_1
     else:
         file_ = arg_1
         rev = arg_2
 
     repo = repo.unfiltered()
 
     timer, fm = gettimer(ui, opts)
 
     rev = int(rev)
 
     revlog = cmdutil.openrevlog(repo, b'perf::delta-find', file_, opts)
 
     deltacomputer = deltautil.deltacomputer(revlog)
 
     node = revlog.node(rev)
     p1r, p2r = revlog.parentrevs(rev)
     p1 = revlog.node(p1r)
     p2 = revlog.node(p2r)
     full_text = revlog.revision(rev)
     textlen = len(full_text)
     cachedelta = None
     flags = revlog.flags(rev)
 
     revinfo = revlogutils.revisioninfo(
         node,
         p1,
         p2,
         [full_text],  # btext
         textlen,
         cachedelta,
         flags,
     )
 
     # Note: we should probably purge the potential caches (like the full
     # manifest cache) between runs.
     def find_one():
         with revlog._datafp() as fh:
             deltacomputer.finddeltainfo(revinfo, fh, target_rev=rev)
 
     timer(find_one)
     fm.end()
 
 
 @command(b'perf::discovery|perfdiscovery', formatteropts, b'PATH')
 def perfdiscovery(ui, repo, path, **opts):
     """benchmark discovery between local repo and the peer at given path"""
     repos = [repo, None]
     timer, fm = gettimer(ui, opts)
 
     try:
         from mercurial.utils.urlutil import get_unique_pull_path_obj
 
         path = get_unique_pull_path_obj(b'perfdiscovery', ui, path)
     except ImportError:
         try:
             from mercurial.utils.urlutil import get_unique_pull_path
 
             path = get_unique_pull_path(b'perfdiscovery', repo, ui, path)[0]
         except ImportError:
             path = ui.expandpath(path)
 
     def s():
         repos[1] = hg.peer(ui, opts, path)
 
     def d():
         setdiscovery.findcommonheads(ui, *repos)
 
     timer(d, setup=s)
     fm.end()
 
 
 @command(
     b'perf::bookmarks|perfbookmarks',
     formatteropts
     + [
         (b'', b'clear-revlogs', False, b'refresh changelog and manifest'),
     ],
 )
 def perfbookmarks(ui, repo, **opts):
     """benchmark parsing bookmarks from disk to memory"""
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
 
     clearrevlogs = opts[b'clear_revlogs']
 
     def s():
         if clearrevlogs:
             clearchangelog(repo)
         clearfilecache(repo, b'_bookmarks')
 
     def d():
         repo._bookmarks
 
     timer(d, setup=s)
     fm.end()
 
 
 @command(
     b'perf::bundle',
     [
         (
             b'r',
             b'rev',
             [],
             b'changesets to bundle',
             b'REV',
         ),
         (
             b't',
             b'type',
             b'none',
             b'bundlespec to use (see `hg help bundlespec`)',
             b'TYPE',
         ),
     ]
     + formatteropts,
     b'REVS',
 )
 def perfbundle(ui, repo, *revs, **opts):
     """benchmark the creation of a bundle from a repository
 
     For now, this only supports "none" compression.
     """
     try:
         from mercurial import bundlecaches
 
         parsebundlespec = bundlecaches.parsebundlespec
     except ImportError:
         from mercurial import exchange
 
         parsebundlespec = exchange.parsebundlespec
 
     from mercurial import discovery
     from mercurial import bundle2
 
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
 
     cl = repo.changelog
     revs = list(revs)
     revs.extend(opts.get(b'rev', ()))
     revs = scmutil.revrange(repo, revs)
     if not revs:
         raise error.Abort(b"not revision specified")
     # make it a consistent set (ie: without topological gaps)
     old_len = len(revs)
     revs = list(repo.revs(b"%ld::%ld", revs, revs))
     if old_len != len(revs):
         new_count = len(revs) - old_len
         msg = b"add %d new revisions to make it a consistent set\n"
         ui.write_err(msg % new_count)
 
     targets = [cl.node(r) for r in repo.revs(b"heads(::%ld)", revs)]
     bases = [cl.node(r) for r in repo.revs(b"heads(::%ld - %ld)", revs, revs)]
     outgoing = discovery.outgoing(repo, bases, targets)
 
     bundle_spec = opts.get(b'type')
 
     bundle_spec = parsebundlespec(repo, bundle_spec, strict=False)
 
     cgversion = bundle_spec.params.get(b"cg.version")
     if cgversion is None:
         if bundle_spec.version == b'v1':
             cgversion = b'01'
         if bundle_spec.version == b'v2':
             cgversion = b'02'
     if cgversion not in changegroup.supportedoutgoingversions(repo):
         err = b"repository does not support bundle version %s"
         raise error.Abort(err % cgversion)
 
     if cgversion == b'01':  # bundle1
         bversion = b'HG10' + bundle_spec.wirecompression
         bcompression = None
     elif cgversion in (b'02', b'03'):
         bversion = b'HG20'
         bcompression = bundle_spec.wirecompression
     else:
         err = b'perf::bundle: unexpected changegroup version %s'
         raise error.ProgrammingError(err % cgversion)
 
     if bcompression is None:
         bcompression = b'UN'
 
     if bcompression != b'UN':
         err = b'perf::bundle: compression currently unsupported: %s'
         raise error.ProgrammingError(err % bcompression)
 
     def do_bundle():
         bundle2.writenewbundle(
             ui,
             repo,
             b'perf::bundle',
             os.devnull,
             bversion,
             outgoing,
             bundle_spec.params,
         )
 
     timer(do_bundle)
     fm.end()
 
 
 @command(b'perf::bundleread|perfbundleread', formatteropts, b'BUNDLE')
 def perfbundleread(ui, repo, bundlepath, **opts):
     """Benchmark reading of bundle files.
 
     This command is meant to isolate the I/O part of bundle reading as
     much as possible.
     """
     from mercurial import (
         bundle2,
         exchange,
         streamclone,
     )
 
     opts = _byteskwargs(opts)
 
     def makebench(fn):
         def run():
             with open(bundlepath, b'rb') as fh:
                 bundle = exchange.readbundle(ui, fh, bundlepath)
                 fn(bundle)
 
         return run
 
     def makereadnbytes(size):
         def run():
             with open(bundlepath, b'rb') as fh:
                 bundle = exchange.readbundle(ui, fh, bundlepath)
                 while bundle.read(size):
                     pass
 
         return run
 
     def makestdioread(size):
         def run():
             with open(bundlepath, b'rb') as fh:
                 while fh.read(size):
                     pass
 
         return run
 
     # bundle1
 
     def deltaiter(bundle):
         for delta in bundle.deltaiter():
             pass
 
     def iterchunks(bundle):
         for chunk in bundle.getchunks():
             pass
 
     # bundle2
 
     def forwardchunks(bundle):
         for chunk in bundle._forwardchunks():
             pass
 
     def iterparts(bundle):
         for part in bundle.iterparts():
             pass
 
     def iterpartsseekable(bundle):
         for part in bundle.iterparts(seekable=True):
             pass
 
     def seek(bundle):
         for part in bundle.iterparts(seekable=True):
             part.seek(0, os.SEEK_END)
 
     def makepartreadnbytes(size):
         def run():
             with open(bundlepath, b'rb') as fh:
                 bundle = exchange.readbundle(ui, fh, bundlepath)
                 for part in bundle.iterparts():
                     while part.read(size):
                         pass
 
         return run
 
     benches = [
         (makestdioread(8192), b'read(8k)'),
         (makestdioread(16384), b'read(16k)'),
         (makestdioread(32768), b'read(32k)'),
         (makestdioread(131072), b'read(128k)'),
     ]
 
     with open(bundlepath, b'rb') as fh:
         bundle = exchange.readbundle(ui, fh, bundlepath)
 
         if isinstance(bundle, changegroup.cg1unpacker):
             benches.extend(
                 [
                     (makebench(deltaiter), b'cg1 deltaiter()'),
                     (makebench(iterchunks), b'cg1 getchunks()'),
                     (makereadnbytes(8192), b'cg1 read(8k)'),
                     (makereadnbytes(16384), b'cg1 read(16k)'),
                     (makereadnbytes(32768), b'cg1 read(32k)'),
                     (makereadnbytes(131072), b'cg1 read(128k)'),
                 ]
             )
         elif isinstance(bundle, bundle2.unbundle20):
             benches.extend(
                 [
                     (makebench(forwardchunks), b'bundle2 forwardchunks()'),
                     (makebench(iterparts), b'bundle2 iterparts()'),
                     (
                         makebench(iterpartsseekable),
                         b'bundle2 iterparts() seekable',
                     ),
                     (makebench(seek), b'bundle2 part seek()'),
                     (makepartreadnbytes(8192), b'bundle2 part read(8k)'),
                     (makepartreadnbytes(16384), b'bundle2 part read(16k)'),
                     (makepartreadnbytes(32768), b'bundle2 part read(32k)'),
                     (makepartreadnbytes(131072), b'bundle2 part read(128k)'),
                 ]
             )
         elif isinstance(bundle, streamclone.streamcloneapplier):
             raise error.Abort(b'stream clone bundles not supported')
         else:
             raise error.Abort(b'unhandled bundle type: %s' % type(bundle))
 
     for fn, title in benches:
         timer, fm = gettimer(ui, opts)
         timer(fn, title=title)
         fm.end()
 
 
 @command(
     b'perf::changegroupchangelog|perfchangegroupchangelog',
     formatteropts
     + [
         (b'', b'cgversion', b'02', b'changegroup version'),
         (b'r', b'rev', b'', b'revisions to add to changegroup'),
     ],
 )
 def perfchangegroupchangelog(ui, repo, cgversion=b'02', rev=None, **opts):
     """Benchmark producing a changelog group for a changegroup.
 
     This measures the time spent processing the changelog during a
     bundle operation. This occurs during `hg bundle` and on a server
     processing a `getbundle` wire protocol request (handles clones
     and pull requests).
 
     By default, all revisions are added to the changegroup.
     """
     opts = _byteskwargs(opts)
     cl = repo.changelog
     nodes = [cl.lookup(r) for r in repo.revs(rev or b'all()')]
     bundler = changegroup.getbundler(cgversion, repo)
 
     def d():
         state, chunks = bundler._generatechangelog(cl, nodes)
         for chunk in chunks:
             pass
 
     timer, fm = gettimer(ui, opts)
 
     # Terminal printing can interfere with timing. So disable it.
     with ui.configoverride({(b'progress', b'disable'): True}):
         timer(d)
 
     fm.end()
 
 
 @command(b'perf::dirs|perfdirs', formatteropts)
 def perfdirs(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     dirstate = repo.dirstate
     b'a' in dirstate
 
     def d():
         dirstate.hasdir(b'a')
         try:
             del dirstate._map._dirs
         except AttributeError:
             pass
 
     timer(d)
     fm.end()
 
 
 @command(
     b'perf::dirstate|perfdirstate',
     [
         (
             b'',
             b'iteration',
             None,
             b'benchmark a full iteration for the dirstate',
         ),
         (
             b'',
             b'contains',
             None,
             b'benchmark a large amount of `nf in dirstate` calls',
         ),
     ]
     + formatteropts,
 )
 def perfdirstate(ui, repo, **opts):
     """benchmap the time of various distate operations
 
     By default benchmark the time necessary to load a dirstate from scratch.
     The dirstate is loaded to the point were a "contains" request can be
     answered.
     """
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     b"a" in repo.dirstate
 
     if opts[b'iteration'] and opts[b'contains']:
         msg = b'only specify one of --iteration or --contains'
         raise error.Abort(msg)
 
     if opts[b'iteration']:
         setup = None
         dirstate = repo.dirstate
 
         def d():
             for f in dirstate:
                 pass
 
     elif opts[b'contains']:
         setup = None
         dirstate = repo.dirstate
         allfiles = list(dirstate)
         # also add file path that will be "missing" from the dirstate
         allfiles.extend([f[::-1] for f in allfiles])
 
         def d():
             for f in allfiles:
                 f in dirstate
 
     else:
 
         def setup():
             repo.dirstate.invalidate()
 
         def d():
             b"a" in repo.dirstate
 
     timer(d, setup=setup)
     fm.end()
 
 
 @command(b'perf::dirstatedirs|perfdirstatedirs', formatteropts)
 def perfdirstatedirs(ui, repo, **opts):
     """benchmap a 'dirstate.hasdir' call from an empty `dirs` cache"""
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     repo.dirstate.hasdir(b"a")
 
     def setup():
         try:
             del repo.dirstate._map._dirs
         except AttributeError:
             pass
 
     def d():
         repo.dirstate.hasdir(b"a")
 
     timer(d, setup=setup)
     fm.end()
 
 
 @command(b'perf::dirstatefoldmap|perfdirstatefoldmap', formatteropts)
 def perfdirstatefoldmap(ui, repo, **opts):
     """benchmap a `dirstate._map.filefoldmap.get()` request
 
     The dirstate filefoldmap cache is dropped between every request.
     """
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     dirstate = repo.dirstate
     dirstate._map.filefoldmap.get(b'a')
 
     def setup():
         del dirstate._map.filefoldmap
 
     def d():
         dirstate._map.filefoldmap.get(b'a')
 
     timer(d, setup=setup)
     fm.end()
 
 
 @command(b'perf::dirfoldmap|perfdirfoldmap', formatteropts)
 def perfdirfoldmap(ui, repo, **opts):
     """benchmap a `dirstate._map.dirfoldmap.get()` request
 
     The dirstate dirfoldmap cache is dropped between every request.
     """
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     dirstate = repo.dirstate
     dirstate._map.dirfoldmap.get(b'a')
 
     def setup():
         del dirstate._map.dirfoldmap
         try:
             del dirstate._map._dirs
         except AttributeError:
             pass
 
     def d():
         dirstate._map.dirfoldmap.get(b'a')
 
     timer(d, setup=setup)
     fm.end()
 
 
 @command(b'perf::dirstatewrite|perfdirstatewrite', formatteropts)
 def perfdirstatewrite(ui, repo, **opts):
     """benchmap the time it take to write a dirstate on disk"""
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     ds = repo.dirstate
     b"a" in ds
 
     def setup():
         ds._dirty = True
 
     def d():
         ds.write(repo.currenttransaction())
 
     with repo.wlock():
         timer(d, setup=setup)
     fm.end()
 
 
 def _getmergerevs(repo, opts):
     """parse command argument to return rev involved in merge
 
     input: options dictionnary with `rev`, `from` and `bse`
     output: (localctx, otherctx, basectx)
     """
     if opts[b'from']:
         fromrev = scmutil.revsingle(repo, opts[b'from'])
         wctx = repo[fromrev]
     else:
         wctx = repo[None]
         # we don't want working dir files to be stat'd in the benchmark, so
         # prime that cache
         wctx.dirty()
     rctx = scmutil.revsingle(repo, opts[b'rev'], opts[b'rev'])
     if opts[b'base']:
         fromrev = scmutil.revsingle(repo, opts[b'base'])
         ancestor = repo[fromrev]
     else:
         ancestor = wctx.ancestor(rctx)
     return (wctx, rctx, ancestor)
 
 
 @command(
     b'perf::mergecalculate|perfmergecalculate',
     [
         (b'r', b'rev', b'.', b'rev to merge against'),
         (b'', b'from', b'', b'rev to merge from'),
         (b'', b'base', b'', b'the revision to use as base'),
     ]
     + formatteropts,
 )
 def perfmergecalculate(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
 
     wctx, rctx, ancestor = _getmergerevs(repo, opts)
 
     def d():
         # acceptremote is True because we don't want prompts in the middle of
         # our benchmark
         merge.calculateupdates(
             repo,
             wctx,
             rctx,
             [ancestor],
             branchmerge=False,
             force=False,
             acceptremote=True,
             followcopies=True,
         )
 
     timer(d)
     fm.end()
 
 
 @command(
     b'perf::mergecopies|perfmergecopies',
     [
         (b'r', b'rev', b'.', b'rev to merge against'),
         (b'', b'from', b'', b'rev to merge from'),
         (b'', b'base', b'', b'the revision to use as base'),
     ]
     + formatteropts,
 )
 def perfmergecopies(ui, repo, **opts):
     """measure runtime of `copies.mergecopies`"""
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     wctx, rctx, ancestor = _getmergerevs(repo, opts)
 
     def d():
         # acceptremote is True because we don't want prompts in the middle of
         # our benchmark
         copies.mergecopies(repo, wctx, rctx, ancestor)
 
     timer(d)
     fm.end()
 
 
 @command(b'perf::pathcopies|perfpathcopies', [], b"REV REV")
 def perfpathcopies(ui, repo, rev1, rev2, **opts):
     """benchmark the copy tracing logic"""
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     ctx1 = scmutil.revsingle(repo, rev1, rev1)
     ctx2 = scmutil.revsingle(repo, rev2, rev2)
 
     def d():
         copies.pathcopies(ctx1, ctx2)
 
     timer(d)
     fm.end()
 
 
 @command(
     b'perf::phases|perfphases',
     [
         (b'', b'full', False, b'include file reading time too'),
     ],
     b"",
 )
 def perfphases(ui, repo, **opts):
     """benchmark phasesets computation"""
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     _phases = repo._phasecache
     full = opts.get(b'full')
 
     def d():
         phases = _phases
         if full:
             clearfilecache(repo, b'_phasecache')
             phases = repo._phasecache
         phases.invalidate()
         phases.loadphaserevs(repo)
 
     timer(d)
     fm.end()
 
 
 @command(b'perf::phasesremote|perfphasesremote', [], b"[DEST]")
 def perfphasesremote(ui, repo, dest=None, **opts):
     """benchmark time needed to analyse phases of the remote server"""
     from mercurial.node import bin
     from mercurial import (
         exchange,
         hg,
         phases,
     )
 
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
 
     path = ui.getpath(dest, default=(b'default-push', b'default'))
     if not path:
         raise error.Abort(
             b'default repository not configured!',
             hint=b"see 'hg help config.paths'",
         )
     if util.safehasattr(path, 'main_path'):
         path = path.get_push_variant()
         dest = path.loc
     else:
         dest = path.pushloc or path.loc
     ui.statusnoi18n(b'analysing phase of %s\n' % util.hidepassword(dest))
     other = hg.peer(repo, opts, dest)
 
     # easier to perform discovery through the operation
     op = exchange.pushoperation(repo, other)
     exchange._pushdiscoverychangeset(op)
 
     remotesubset = op.fallbackheads
 
     with other.commandexecutor() as e:
         remotephases = e.callcommand(
             b'listkeys', {b'namespace': b'phases'}
         ).result()
     del other
     publishing = remotephases.get(b'publishing', False)
     if publishing:
         ui.statusnoi18n(b'publishing: yes\n')
     else:
         ui.statusnoi18n(b'publishing: no\n')
 
     has_node = getattr(repo.changelog.index, 'has_node', None)
     if has_node is None:
         has_node = repo.changelog.nodemap.__contains__
     nonpublishroots = 0
     for nhex, phase in remotephases.iteritems():
         if nhex == b'publishing':  # ignore data related to publish option
             continue
         node = bin(nhex)
         if has_node(node) and int(phase):
             nonpublishroots += 1
     ui.statusnoi18n(b'number of roots: %d\n' % len(remotephases))
     ui.statusnoi18n(b'number of known non public roots: %d\n' % nonpublishroots)
 
     def d():
         phases.remotephasessummary(repo, remotesubset, remotephases)
 
     timer(d)
     fm.end()
 
 
 @command(
     b'perf::manifest|perfmanifest',
     [
         (b'm', b'manifest-rev', False, b'Look up a manifest node revision'),
         (b'', b'clear-disk', False, b'clear on-disk caches too'),
     ]
     + formatteropts,
     b'REV|NODE',
 )
 def perfmanifest(ui, repo, rev, manifest_rev=False, clear_disk=False, **opts):
     """benchmark the time to read a manifest from disk and return a usable
     dict-like object
 
     Manifest caches are cleared before retrieval."""
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     if not manifest_rev:
         ctx = scmutil.revsingle(repo, rev, rev)
         t = ctx.manifestnode()
     else:
         from mercurial.node import bin
 
         if len(rev) == 40:
             t = bin(rev)
         else:
             try:
                 rev = int(rev)
 
                 if util.safehasattr(repo.manifestlog, b'getstorage'):
                     t = repo.manifestlog.getstorage(b'').node(rev)
                 else:
                     t = repo.manifestlog._revlog.lookup(rev)
             except ValueError:
                 raise error.Abort(
                     b'manifest revision must be integer or full node'
                 )
 
     def d():
         repo.manifestlog.clearcaches(clear_persisted_data=clear_disk)
         repo.manifestlog[t].read()
 
     timer(d)
     fm.end()
 
 
 @command(b'perf::changeset|perfchangeset', formatteropts)
 def perfchangeset(ui, repo, rev, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     n = scmutil.revsingle(repo, rev).node()
 
     def d():
         repo.changelog.read(n)
         # repo.changelog._cache = None
 
     timer(d)
     fm.end()
 
 
 @command(b'perf::ignore|perfignore', formatteropts)
 def perfignore(ui, repo, **opts):
     """benchmark operation related to computing ignore"""
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     dirstate = repo.dirstate
 
     def setupone():
         dirstate.invalidate()
         clearfilecache(dirstate, b'_ignore')
 
     def runone():
         dirstate._ignore
 
     timer(runone, setup=setupone, title=b"load")
     fm.end()
 
 
 @command(
     b'perf::index|perfindex',
     [
         (b'', b'rev', [], b'revision to be looked up (default tip)'),
         (b'', b'no-lookup', None, b'do not revision lookup post creation'),
     ]
     + formatteropts,
 )
 def perfindex(ui, repo, **opts):
     """benchmark index creation time followed by a lookup
 
     The default is to look `tip` up. Depending on the index implementation,
     the revision looked up can matters. For example, an implementation
     scanning the index will have a faster lookup time for `--rev tip` than for
     `--rev 0`. The number of looked up revisions and their order can also
     matters.
 
     Example of useful set to test:
 
     * tip
     * 0
     * -10:
     * :10
     * -10: + :10
     * :10: + -10:
     * -10000:
     * -10000: + 0
 
     It is not currently possible to check for lookup of a missing node. For
     deeper lookup benchmarking, checkout the `perfnodemap` command."""
     import mercurial.revlog
 
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     mercurial.revlog._prereadsize = 2 ** 24  # disable lazy parser in old hg
     if opts[b'no_lookup']:
         if opts['rev']:
             raise error.Abort('--no-lookup and --rev are mutually exclusive')
         nodes = []
     elif not opts[b'rev']:
         nodes = [repo[b"tip"].node()]
     else:
         revs = scmutil.revrange(repo, opts[b'rev'])
         cl = repo.changelog
         nodes = [cl.node(r) for r in revs]
 
     unfi = repo.unfiltered()
     # find the filecache func directly
     # This avoid polluting the benchmark with the filecache logic
     makecl = unfi.__class__.changelog.func
 
     def setup():
         # probably not necessary, but for good measure
         clearchangelog(unfi)
 
     def d():
         cl = makecl(unfi)
         for n in nodes:
             cl.rev(n)
 
     timer(d, setup=setup)
     fm.end()
 
 
 @command(
     b'perf::nodemap|perfnodemap',
     [
         (b'', b'rev', [], b'revision to be looked up (default tip)'),
         (b'', b'clear-caches', True, b'clear revlog cache between calls'),
     ]
     + formatteropts,
 )
 def perfnodemap(ui, repo, **opts):
     """benchmark the time necessary to look up revision from a cold nodemap
 
     Depending on the implementation, the amount and order of revision we look
     up can varies. Example of useful set to test:
     * tip
     * 0
     * -10:
     * :10
     * -10: + :10
     * :10: + -10:
     * -10000:
     * -10000: + 0
 
     The command currently focus on valid binary lookup. Benchmarking for
     hexlookup, prefix lookup and missing lookup would also be valuable.
     """
     import mercurial.revlog
 
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     mercurial.revlog._prereadsize = 2 ** 24  # disable lazy parser in old hg
 
     unfi = repo.unfiltered()
     clearcaches = opts[b'clear_caches']
     # find the filecache func directly
     # This avoid polluting the benchmark with the filecache logic
     makecl = unfi.__class__.changelog.func
     if not opts[b'rev']:
         raise error.Abort(b'use --rev to specify revisions to look up')
     revs = scmutil.revrange(repo, opts[b'rev'])
     cl = repo.changelog
     nodes = [cl.node(r) for r in revs]
 
     # use a list to pass reference to a nodemap from one closure to the next
     nodeget = [None]
 
     def setnodeget():
         # probably not necessary, but for good measure
         clearchangelog(unfi)
         cl = makecl(unfi)
         if util.safehasattr(cl.index, 'get_rev'):
             nodeget[0] = cl.index.get_rev
         else:
             nodeget[0] = cl.nodemap.get
 
     def d():
         get = nodeget[0]
         for n in nodes:
             get(n)
 
     setup = None
     if clearcaches:
 
         def setup():
             setnodeget()
 
     else:
         setnodeget()
         d()  # prewarm the data structure
     timer(d, setup=setup)
     fm.end()
 
 
 @command(b'perf::startup|perfstartup', formatteropts)
 def perfstartup(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
 
     def d():
         if os.name != 'nt':
             os.system(
                 b"HGRCPATH= %s version -q > /dev/null" % fsencode(sys.argv[0])
             )
         else:
             os.environ['HGRCPATH'] = r' '
             os.system("%s version -q > NUL" % sys.argv[0])
 
     timer(d)
     fm.end()
 
 
 def _find_stream_generator(version):
     """find the proper generator function for this stream version"""
     import mercurial.streamclone
 
     available = {}
 
     # try to fetch a v1 generator
     generatev1 = getattr(mercurial.streamclone, "generatev1", None)
     if generatev1 is not None:
 
         def generate(repo):
             entries, bytes, data = generatev2(repo, None, None, True)
             return data
 
         available[b'v1'] = generatev1
     # try to fetch a v2 generator
     generatev2 = getattr(mercurial.streamclone, "generatev2", None)
     if generatev2 is not None:
 
         def generate(repo):
             entries, bytes, data = generatev2(repo, None, None, True)
             return data
 
         available[b'v2'] = generate
     # try to fetch a v3 generator
     generatev3 = getattr(mercurial.streamclone, "generatev3", None)
     if generatev3 is not None:
 
         def generate(repo):
             entries, bytes, data = generatev3(repo, None, None, True)
             return data
 
         available[b'v3-exp'] = generate
 
     # resolve the request
     if version == b"latest":
         # latest is the highest non experimental version
         latest_key = max(v for v in available if b'-exp' not in v)
         return available[latest_key]
     elif version in available:
         return available[version]
     else:
         msg = b"unkown or unavailable version: %s"
         msg %= version
         hint = b"available versions: %s"
         hint %= b', '.join(sorted(available))
         raise error.Abort(msg, hint=hint)
 
 
 @command(
     b'perf::stream-locked-section',
     [
         (
             b'',
             b'stream-version',
             b'latest',
             b'stream version to use ("v1", "v2", "v3" or "latest", (the default))',
         ),
     ]
     + formatteropts,
 )
 def perf_stream_clone_scan(ui, repo, stream_version, **opts):
     """benchmark the initial, repo-locked, section of a stream-clone"""
 
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
 
     # deletion of the generator may trigger some cleanup that we do not want to
     # measure
     result_holder = [None]
 
     def setupone():
         result_holder[0] = None
 
     generate = _find_stream_generator(stream_version)
 
     def runone():
         # the lock is held for the duration the initialisation
         result_holder[0] = generate(repo)
 
     timer(runone, setup=setupone, title=b"load")
     fm.end()
 
 
 @command(
     b'perf::stream-generate',
     [
         (
             b'',
             b'stream-version',
             b'latest',
             b'stream version to us ("v1", "v2" or "latest", (the default))',
         ),
     ]
     + formatteropts,
 )
 def perf_stream_clone_generate(ui, repo, stream_version, **opts):
     """benchmark the full generation of a stream clone"""
 
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
 
     # deletion of the generator may trigger some cleanup that we do not want to
     # measure
 
     generate = _find_stream_generator(stream_version)
 
     def runone():
         # the lock is held for the duration the initialisation
         for chunk in generate(repo):
             pass
 
     timer(runone, title=b"generate")
     fm.end()
 
 
 @command(
     b'perf::stream-consume',
     formatteropts,
 )
 def perf_stream_clone_consume(ui, repo, filename, **opts):
     """benchmark the full application of a stream clone
 
     This include the creation of the repository
     """
     # try except to appease check code
     msg = b"mercurial too old, missing necessary module: %s"
     try:
         from mercurial import bundle2
     except ImportError as exc:
         msg %= _bytestr(exc)
         raise error.Abort(msg)
     try:
         from mercurial import exchange
     except ImportError as exc:
         msg %= _bytestr(exc)
         raise error.Abort(msg)
     try:
         from mercurial import hg
     except ImportError as exc:
         msg %= _bytestr(exc)
         raise error.Abort(msg)
     try:
         from mercurial import localrepo
     except ImportError as exc:
         msg %= _bytestr(exc)
         raise error.Abort(msg)
 
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
 
     # deletion of the generator may trigger some cleanup that we do not want to
     # measure
     if not (os.path.isfile(filename) and os.access(filename, os.R_OK)):
         raise error.Abort("not a readable file: %s" % filename)
 
     run_variables = [None, None]
 
     @contextlib.contextmanager
     def context():
         with open(filename, mode='rb') as bundle:
             with tempfile.TemporaryDirectory() as tmp_dir:
                 tmp_dir = fsencode(tmp_dir)
                 run_variables[0] = bundle
                 run_variables[1] = tmp_dir
                 yield
                 run_variables[0] = None
                 run_variables[1] = None
 
     def runone():
         bundle = run_variables[0]
         tmp_dir = run_variables[1]
         # only pass ui when no srcrepo
         localrepo.createrepository(
             repo.ui, tmp_dir, requirements=repo.requirements
         )
         target = hg.repository(repo.ui, tmp_dir)
         gen = exchange.readbundle(target.ui, bundle, bundle.name)
         # stream v1
         if util.safehasattr(gen, 'apply'):
             gen.apply(target)
         else:
             with target.transaction(b"perf::stream-consume") as tr:
                 bundle2.applybundle(
                     target,
                     gen,
                     tr,
                     source=b'unbundle',
                     url=filename,
                 )
 
     timer(runone, context=context, title=b"consume")
     fm.end()
 
 
 @command(b'perf::parents|perfparents', formatteropts)
 def perfparents(ui, repo, **opts):
     """benchmark the time necessary to fetch one changeset's parents.
 
     The fetch is done using the `node identifier`, traversing all object layers
     from the repository object. The first N revisions will be used for this
     benchmark. N is controlled by the ``perf.parentscount`` config option
     (default: 1000).
     """
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     # control the number of commits perfparents iterates over
     # experimental config: perf.parentscount
     count = getint(ui, b"perf", b"parentscount", 1000)
     if len(repo.changelog) < count:
         raise error.Abort(b"repo needs %d commits for this test" % count)
     repo = repo.unfiltered()
     nl = [repo.changelog.node(i) for i in _xrange(count)]
 
     def d():
         for n in nl:
             repo.changelog.parents(n)
 
     timer(d)
     fm.end()
 
 
 @command(b'perf::ctxfiles|perfctxfiles', formatteropts)
 def perfctxfiles(ui, repo, x, **opts):
     opts = _byteskwargs(opts)
     x = int(x)
     timer, fm = gettimer(ui, opts)
 
     def d():
         len(repo[x].files())
 
     timer(d)
     fm.end()
 
 
 @command(b'perf::rawfiles|perfrawfiles', formatteropts)
 def perfrawfiles(ui, repo, x, **opts):
     opts = _byteskwargs(opts)
     x = int(x)
     timer, fm = gettimer(ui, opts)
     cl = repo.changelog
 
     def d():
         len(cl.read(x)[3])
 
     timer(d)
     fm.end()
 
 
 @command(b'perf::lookup|perflookup', formatteropts)
 def perflookup(ui, repo, rev, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     timer(lambda: len(repo.lookup(rev)))
     fm.end()
 
 
 @command(
     b'perf::linelogedits|perflinelogedits',
     [
         (b'n', b'edits', 10000, b'number of edits'),
         (b'', b'max-hunk-lines', 10, b'max lines in a hunk'),
     ],
     norepo=True,
 )
 def perflinelogedits(ui, **opts):
     from mercurial import linelog
 
     opts = _byteskwargs(opts)
 
     edits = opts[b'edits']
     maxhunklines = opts[b'max_hunk_lines']
 
     maxb1 = 100000
     random.seed(0)
     randint = random.randint
     currentlines = 0
     arglist = []
     for rev in _xrange(edits):
         a1 = randint(0, currentlines)
         a2 = randint(a1, min(currentlines, a1 + maxhunklines))
         b1 = randint(0, maxb1)
         b2 = randint(b1, b1 + maxhunklines)
         currentlines += (b2 - b1) - (a2 - a1)
         arglist.append((rev, a1, a2, b1, b2))
 
     def d():
         ll = linelog.linelog()
         for args in arglist:
             ll.replacelines(*args)
 
     timer, fm = gettimer(ui, opts)
     timer(d)
     fm.end()
 
 
 @command(b'perf::revrange|perfrevrange', formatteropts)
 def perfrevrange(ui, repo, *specs, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     revrange = scmutil.revrange
     timer(lambda: len(revrange(repo, specs)))
     fm.end()
 
 
 @command(b'perf::nodelookup|perfnodelookup', formatteropts)
 def perfnodelookup(ui, repo, rev, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     import mercurial.revlog
 
     mercurial.revlog._prereadsize = 2 ** 24  # disable lazy parser in old hg
     n = scmutil.revsingle(repo, rev).node()
 
     try:
         cl = revlog(getsvfs(repo), radix=b"00changelog")
     except TypeError:
         cl = revlog(getsvfs(repo), indexfile=b"00changelog.i")
 
     def d():
         cl.rev(n)
         clearcaches(cl)
 
     timer(d)
     fm.end()
 
 
 @command(
     b'perf::log|perflog',
     [(b'', b'rename', False, b'ask log to follow renames')] + formatteropts,
 )
 def perflog(ui, repo, rev=None, **opts):
     opts = _byteskwargs(opts)
     if rev is None:
         rev = []
     timer, fm = gettimer(ui, opts)
     ui.pushbuffer()
     timer(
         lambda: commands.log(
             ui, repo, rev=rev, date=b'', user=b'', copies=opts.get(b'rename')
         )
     )
     ui.popbuffer()
     fm.end()
 
 
 @command(b'perf::moonwalk|perfmoonwalk', formatteropts)
 def perfmoonwalk(ui, repo, **opts):
     """benchmark walking the changelog backwards
 
     This also loads the changelog data for each revision in the changelog.
     """
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
 
     def moonwalk():
         for i in repo.changelog.revs(start=(len(repo) - 1), stop=-1):
             ctx = repo[i]
             ctx.branch()  # read changelog data (in addition to the index)
 
     timer(moonwalk)
     fm.end()
 
 
 @command(
     b'perf::templating|perftemplating',
     [
         (b'r', b'rev', [], b'revisions to run the template on'),
     ]
     + formatteropts,
 )
 def perftemplating(ui, repo, testedtemplate=None, **opts):
     """test the rendering time of a given template"""
     if makelogtemplater is None:
         raise error.Abort(
             b"perftemplating not available with this Mercurial",
             hint=b"use 4.3 or later",
         )
 
     opts = _byteskwargs(opts)
 
     nullui = ui.copy()
     nullui.fout = open(os.devnull, 'wb')
     nullui.disablepager()
     revs = opts.get(b'rev')
     if not revs:
         revs = [b'all()']
     revs = list(scmutil.revrange(repo, revs))
 
     defaulttemplate = (
         b'{date|shortdate} [{rev}:{node|short}]'
         b' {author|person}: {desc|firstline}\n'
     )
     if testedtemplate is None:
         testedtemplate = defaulttemplate
     displayer = makelogtemplater(nullui, repo, testedtemplate)
 
     def format():
         for r in revs:
             ctx = repo[r]
             displayer.show(ctx)
             displayer.flush(ctx)
 
     timer, fm = gettimer(ui, opts)
     timer(format)
     fm.end()
 
 
 def _displaystats(ui, opts, entries, data):
     # use a second formatter because the data are quite different, not sure
     # how it flies with the templater.
     fm = ui.formatter(b'perf-stats', opts)
     for key, title in entries:
         values = data[key]
         nbvalues = len(data)
         values.sort()
         stats = {
             'key': key,
             'title': title,
             'nbitems': len(values),
             'min': values[0][0],
             '10%': values[(nbvalues * 10) // 100][0],
             '25%': values[(nbvalues * 25) // 100][0],
             '50%': values[(nbvalues * 50) // 100][0],
             '75%': values[(nbvalues * 75) // 100][0],
             '80%': values[(nbvalues * 80) // 100][0],
             '85%': values[(nbvalues * 85) // 100][0],
             '90%': values[(nbvalues * 90) // 100][0],
             '95%': values[(nbvalues * 95) // 100][0],
             '99%': values[(nbvalues * 99) // 100][0],
             'max': values[-1][0],
         }
         fm.startitem()
         fm.data(**stats)
         # make node pretty for the human output
         fm.plain('### %s (%d items)\n' % (title, len(values)))
         lines = [
             'min',
             '10%',
             '25%',
             '50%',
             '75%',
             '80%',
             '85%',
             '90%',
             '95%',
             '99%',
             'max',
         ]
         for l in lines:
             fm.plain('%s: %s\n' % (l, stats[l]))
     fm.end()
 
 
 @command(
     b'perf::helper-mergecopies|perfhelper-mergecopies',
     formatteropts
     + [
         (b'r', b'revs', [], b'restrict search to these revisions'),
         (b'', b'timing', False, b'provides extra data (costly)'),
         (b'', b'stats', False, b'provides statistic about the measured data'),
     ],
 )
 def perfhelpermergecopies(ui, repo, revs=[], **opts):
     """find statistics about potential parameters for `perfmergecopies`
 
     This command find (base, p1, p2) triplet relevant for copytracing
     benchmarking in the context of a merge.  It reports values for some of the
     parameters that impact merge copy tracing time during merge.
 
     If `--timing` is set, rename detection is run and the associated timing
     will be reported. The extra details come at the cost of slower command
     execution.
 
     Since rename detection is only run once, other factors might easily
     affect the precision of the timing. However it should give a good
     approximation of which revision triplets are very costly.
     """
     opts = _byteskwargs(opts)
     fm = ui.formatter(b'perf', opts)
     dotiming = opts[b'timing']
     dostats = opts[b'stats']
 
     output_template = [
         ("base", "%(base)12s"),
         ("p1", "%(p1.node)12s"),
         ("p2", "%(p2.node)12s"),
         ("p1.nb-revs", "%(p1.nbrevs)12d"),
         ("p1.nb-files", "%(p1.nbmissingfiles)12d"),
         ("p1.renames", "%(p1.renamedfiles)12d"),
         ("p1.time", "%(p1.time)12.3f"),
         ("p2.nb-revs", "%(p2.nbrevs)12d"),
         ("p2.nb-files", "%(p2.nbmissingfiles)12d"),
         ("p2.renames", "%(p2.renamedfiles)12d"),
         ("p2.time", "%(p2.time)12.3f"),
         ("renames", "%(nbrenamedfiles)12d"),
         ("total.time", "%(time)12.3f"),
     ]
     if not dotiming:
         output_template = [
             i
             for i in output_template
             if not ('time' in i[0] or 'renames' in i[0])
         ]
     header_names = [h for (h, v) in output_template]
     output = ' '.join([v for (h, v) in output_template]) + '\n'
     header = ' '.join(['%12s'] * len(header_names)) + '\n'
     fm.plain(header % tuple(header_names))
 
     if not revs:
         revs = ['all()']
     revs = scmutil.revrange(repo, revs)
 
     if dostats:
         alldata = {
             'nbrevs': [],
             'nbmissingfiles': [],
         }
         if dotiming:
             alldata['parentnbrenames'] = []
             alldata['totalnbrenames'] = []
             alldata['parenttime'] = []
             alldata['totaltime'] = []
 
     roi = repo.revs('merge() and %ld', revs)
     for r in roi:
         ctx = repo[r]
         p1 = ctx.p1()
         p2 = ctx.p2()
         bases = repo.changelog._commonancestorsheads(p1.rev(), p2.rev())
         for b in bases:
             b = repo[b]
             p1missing = copies._computeforwardmissing(b, p1)
             p2missing = copies._computeforwardmissing(b, p2)
             data = {
                 b'base': b.hex(),
                 b'p1.node': p1.hex(),
                 b'p1.nbrevs': len(repo.revs('only(%d, %d)', p1.rev(), b.rev())),
                 b'p1.nbmissingfiles': len(p1missing),
                 b'p2.node': p2.hex(),
                 b'p2.nbrevs': len(repo.revs('only(%d, %d)', p2.rev(), b.rev())),
                 b'p2.nbmissingfiles': len(p2missing),
             }
             if dostats:
                 if p1missing:
                     alldata['nbrevs'].append(
                         (data['p1.nbrevs'], b.hex(), p1.hex())
                     )
                     alldata['nbmissingfiles'].append(
                         (data['p1.nbmissingfiles'], b.hex(), p1.hex())
                     )
                 if p2missing:
                     alldata['nbrevs'].append(
                         (data['p2.nbrevs'], b.hex(), p2.hex())
                     )
                     alldata['nbmissingfiles'].append(
                         (data['p2.nbmissingfiles'], b.hex(), p2.hex())
                     )
             if dotiming:
                 begin = util.timer()
                 mergedata = copies.mergecopies(repo, p1, p2, b)
                 end = util.timer()
                 # not very stable timing since we did only one run
                 data['time'] = end - begin
                 # mergedata contains five dicts: "copy", "movewithdir",
                 # "diverge", "renamedelete" and "dirmove".
                 # The first 4 are about renamed file so lets count that.
                 renames = len(mergedata[0])
                 renames += len(mergedata[1])
                 renames += len(mergedata[2])
                 renames += len(mergedata[3])
                 data['nbrenamedfiles'] = renames
                 begin = util.timer()
                 p1renames = copies.pathcopies(b, p1)
                 end = util.timer()
                 data['p1.time'] = end - begin
                 begin = util.timer()
                 p2renames = copies.pathcopies(b, p2)
                 end = util.timer()
                 data['p2.time'] = end - begin
                 data['p1.renamedfiles'] = len(p1renames)
                 data['p2.renamedfiles'] = len(p2renames)
 
                 if dostats:
                     if p1missing:
                         alldata['parentnbrenames'].append(
                             (data['p1.renamedfiles'], b.hex(), p1.hex())
                         )
                         alldata['parenttime'].append(
                             (data['p1.time'], b.hex(), p1.hex())
                         )
                     if p2missing:
                         alldata['parentnbrenames'].append(
                             (data['p2.renamedfiles'], b.hex(), p2.hex())
                         )
                         alldata['parenttime'].append(
                             (data['p2.time'], b.hex(), p2.hex())
                         )
                     if p1missing or p2missing:
                         alldata['totalnbrenames'].append(
                             (
                                 data['nbrenamedfiles'],
                                 b.hex(),
                                 p1.hex(),
                                 p2.hex(),
                             )
                         )
                         alldata['totaltime'].append(
                             (data['time'], b.hex(), p1.hex(), p2.hex())
                         )
             fm.startitem()
             fm.data(**data)
             # make node pretty for the human output
             out = data.copy()
             out['base'] = fm.hexfunc(b.node())
             out['p1.node'] = fm.hexfunc(p1.node())
             out['p2.node'] = fm.hexfunc(p2.node())
             fm.plain(output % out)
 
     fm.end()
     if dostats:
         # use a second formatter because the data are quite different, not sure
         # how it flies with the templater.
         entries = [
             ('nbrevs', 'number of revision covered'),
             ('nbmissingfiles', 'number of missing files at head'),
         ]
         if dotiming:
             entries.append(
                 ('parentnbrenames', 'rename from one parent to base')
             )
             entries.append(('totalnbrenames', 'total number of renames'))
             entries.append(('parenttime', 'time for one parent'))
             entries.append(('totaltime', 'time for both parents'))
         _displaystats(ui, opts, entries, alldata)
 
 
 @command(
     b'perf::helper-pathcopies|perfhelper-pathcopies',
     formatteropts
     + [
         (b'r', b'revs', [], b'restrict search to these revisions'),
         (b'', b'timing', False, b'provides extra data (costly)'),
         (b'', b'stats', False, b'provides statistic about the measured data'),
     ],
 )
 def perfhelperpathcopies(ui, repo, revs=[], **opts):
     """find statistic about potential parameters for the `perftracecopies`
 
     This command find source-destination pair relevant for copytracing testing.
     It report value for some of the parameters that impact copy tracing time.
 
     If `--timing` is set, rename detection is run and the associated timing
     will be reported. The extra details comes at the cost of a slower command
     execution.
 
     Since the rename detection is only run once, other factors might easily
     affect the precision of the timing. However it should give a good
     approximation of which revision pairs are very costly.
     """
     opts = _byteskwargs(opts)
     fm = ui.formatter(b'perf', opts)
     dotiming = opts[b'timing']
     dostats = opts[b'stats']
 
     if dotiming:
         header = '%12s %12s %12s %12s %12s %12s\n'
         output = (
             "%(source)12s %(destination)12s "
             "%(nbrevs)12d %(nbmissingfiles)12d "
             "%(nbrenamedfiles)12d %(time)18.5f\n"
         )
         header_names = (
             "source",
             "destination",
             "nb-revs",
             "nb-files",
             "nb-renames",
             "time",
         )
         fm.plain(header % header_names)
     else:
         header = '%12s %12s %12s %12s\n'
         output = (
             "%(source)12s %(destination)12s "
             "%(nbrevs)12d %(nbmissingfiles)12d\n"
         )
         fm.plain(header % ("source", "destination", "nb-revs", "nb-files"))
 
     if not revs:
         revs = ['all()']
     revs = scmutil.revrange(repo, revs)
 
     if dostats:
         alldata = {
             'nbrevs': [],
             'nbmissingfiles': [],
         }
         if dotiming:
             alldata['nbrenames'] = []
             alldata['time'] = []
 
     roi = repo.revs('merge() and %ld', revs)
     for r in roi:
         ctx = repo[r]
         p1 = ctx.p1().rev()
         p2 = ctx.p2().rev()
         bases = repo.changelog._commonancestorsheads(p1, p2)
         for p in (p1, p2):
             for b in bases:
                 base = repo[b]
                 parent = repo[p]
                 missing = copies._computeforwardmissing(base, parent)
                 if not missing:
                     continue
                 data = {
                     b'source': base.hex(),
                     b'destination': parent.hex(),
                     b'nbrevs': len(repo.revs('only(%d, %d)', p, b)),
                     b'nbmissingfiles': len(missing),
                 }
                 if dostats:
                     alldata['nbrevs'].append(
                         (
                             data['nbrevs'],
                             base.hex(),
                             parent.hex(),
                         )
                     )
                     alldata['nbmissingfiles'].append(
                         (
                             data['nbmissingfiles'],
                             base.hex(),
                             parent.hex(),
                         )
                     )
                 if dotiming:
                     begin = util.timer()
                     renames = copies.pathcopies(base, parent)
                     end = util.timer()
                     # not very stable timing since we did only one run
                     data['time'] = end - begin
                     data['nbrenamedfiles'] = len(renames)
                     if dostats:
                         alldata['time'].append(
                             (
                                 data['time'],
                                 base.hex(),
                                 parent.hex(),
                             )
                         )
                         alldata['nbrenames'].append(
                             (
                                 data['nbrenamedfiles'],
                                 base.hex(),
                                 parent.hex(),
                             )
                         )
                 fm.startitem()
                 fm.data(**data)
                 out = data.copy()
                 out['source'] = fm.hexfunc(base.node())
                 out['destination'] = fm.hexfunc(parent.node())
                 fm.plain(output % out)
 
     fm.end()
     if dostats:
         entries = [
             ('nbrevs', 'number of revision covered'),
             ('nbmissingfiles', 'number of missing files at head'),
         ]
         if dotiming:
             entries.append(('nbrenames', 'renamed files'))
             entries.append(('time', 'time'))
         _displaystats(ui, opts, entries, alldata)
 
 
 @command(b'perf::cca|perfcca', formatteropts)
 def perfcca(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     timer(lambda: scmutil.casecollisionauditor(ui, False, repo.dirstate))
     fm.end()
 
 
 @command(b'perf::fncacheload|perffncacheload', formatteropts)
 def perffncacheload(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     s = repo.store
 
     def d():
         s.fncache._load()
 
     timer(d)
     fm.end()
 
 
 @command(b'perf::fncachewrite|perffncachewrite', formatteropts)
 def perffncachewrite(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     s = repo.store
     lock = repo.lock()
     s.fncache._load()
     tr = repo.transaction(b'perffncachewrite')
     tr.addbackup(b'fncache')
 
     def d():
         s.fncache._dirty = True
         s.fncache.write(tr)
 
     timer(d)
     tr.close()
     lock.release()
     fm.end()
 
 
 @command(b'perf::fncacheencode|perffncacheencode', formatteropts)
 def perffncacheencode(ui, repo, **opts):
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     s = repo.store
     s.fncache._load()
 
     def d():
         for p in s.fncache.entries:
             s.encode(p)
 
     timer(d)
     fm.end()
 
 
 def _bdiffworker(q, blocks, xdiff, ready, done):
     while not done.is_set():
         pair = q.get()
         while pair is not None:
             if xdiff:
                 mdiff.bdiff.xdiffblocks(*pair)
             elif blocks:
                 mdiff.bdiff.blocks(*pair)
             else:
                 mdiff.textdiff(*pair)
             q.task_done()
             pair = q.get()
         q.task_done()  # for the None one
         with ready:
             ready.wait()
 
 
 def _manifestrevision(repo, mnode):
     ml = repo.manifestlog
 
     if util.safehasattr(ml, b'getstorage'):
         store = ml.getstorage(b'')
     else:
         store = ml._revlog
 
     return store.revision(mnode)
 
 
 @command(
     b'perf::bdiff|perfbdiff',
     revlogopts
     + formatteropts
     + [
         (
             b'',
             b'count',
             1,
             b'number of revisions to test (when using --startrev)',
         ),
         (b'', b'alldata', False, b'test bdiffs for all associated revisions'),
         (b'', b'threads', 0, b'number of thread to use (disable with 0)'),
         (b'', b'blocks', False, b'test computing diffs into blocks'),
         (b'', b'xdiff', False, b'use xdiff algorithm'),
     ],
     b'-c|-m|FILE REV',
 )
 def perfbdiff(ui, repo, file_, rev=None, count=None, threads=0, **opts):
     """benchmark a bdiff between revisions
 
     By default, benchmark a bdiff between its delta parent and itself.
 
     With ``--count``, benchmark bdiffs between delta parents and self for N
     revisions starting at the specified revision.
 
     With ``--alldata``, assume the requested revision is a changeset and
     measure bdiffs for all changes related to that changeset (manifest
     and filelogs).
     """
     opts = _byteskwargs(opts)
 
     if opts[b'xdiff'] and not opts[b'blocks']:
         raise error.CommandError(b'perfbdiff', b'--xdiff requires --blocks')
 
     if opts[b'alldata']:
         opts[b'changelog'] = True
 
     if opts.get(b'changelog') or opts.get(b'manifest'):
         file_, rev = None, file_
     elif rev is None:
         raise error.CommandError(b'perfbdiff', b'invalid arguments')
 
     blocks = opts[b'blocks']
     xdiff = opts[b'xdiff']
     textpairs = []
 
     r = cmdutil.openrevlog(repo, b'perfbdiff', file_, opts)
 
     startrev = r.rev(r.lookup(rev))
     for rev in range(startrev, min(startrev + count, len(r) - 1)):
         if opts[b'alldata']:
             # Load revisions associated with changeset.
             ctx = repo[rev]
             mtext = _manifestrevision(repo, ctx.manifestnode())
             for pctx in ctx.parents():
                 pman = _manifestrevision(repo, pctx.manifestnode())
                 textpairs.append((pman, mtext))
 
             # Load filelog revisions by iterating manifest delta.
             man = ctx.manifest()
             pman = ctx.p1().manifest()
             for filename, change in pman.diff(man).items():
                 fctx = repo.file(filename)
                 f1 = fctx.revision(change[0][0] or -1)
                 f2 = fctx.revision(change[1][0] or -1)
                 textpairs.append((f1, f2))
         else:
             dp = r.deltaparent(rev)
             textpairs.append((r.revision(dp), r.revision(rev)))
 
     withthreads = threads > 0
     if not withthreads:
 
         def d():
             for pair in textpairs:
                 if xdiff:
                     mdiff.bdiff.xdiffblocks(*pair)
                 elif blocks:
                     mdiff.bdiff.blocks(*pair)
                 else:
                     mdiff.textdiff(*pair)
 
     else:
         q = queue()
         for i in _xrange(threads):
             q.put(None)
         ready = threading.Condition()
         done = threading.Event()
         for i in _xrange(threads):
             threading.Thread(
                 target=_bdiffworker, args=(q, blocks, xdiff, ready, done)
             ).start()
         q.join()
 
         def d():
             for pair in textpairs:
                 q.put(pair)
             for i in _xrange(threads):
                 q.put(None)
             with ready:
                 ready.notify_all()
             q.join()
 
     timer, fm = gettimer(ui, opts)
     timer(d)
     fm.end()
 
     if withthreads:
         done.set()
         for i in _xrange(threads):
             q.put(None)
         with ready:
             ready.notify_all()
 
 
 @command(
     b'perf::unbundle',
     formatteropts,
     b'BUNDLE_FILE',
 )
 def perf_unbundle(ui, repo, fname, **opts):
     """benchmark application of a bundle in a repository.
 
     This does not include the final transaction processing"""
 
     from mercurial import exchange
     from mercurial import bundle2
     from mercurial import transaction
 
     opts = _byteskwargs(opts)
 
     ###  some compatibility hotfix
     #
     # the data attribute is dropped in 63edc384d3b7 a changeset introducing a
     # critical regression that break transaction rollback for files that are
     # de-inlined.
     method = transaction.transaction._addentry
     pre_63edc384d3b7 = "data" in getargspec(method).args
     # the `detailed_exit_code` attribute is introduced in 33c0c25d0b0f
     # a changeset that is a close descendant of 18415fc918a1, the changeset
     # that conclude the fix run for the bug introduced in 63edc384d3b7.
     args = getargspec(error.Abort.__init__).args
     post_18415fc918a1 = "detailed_exit_code" in args
 
     old_max_inline = None
     try:
         if not (pre_63edc384d3b7 or post_18415fc918a1):
             # disable inlining
             old_max_inline = mercurial.revlog._maxinline
             # large enough to never happen
             mercurial.revlog._maxinline = 2 ** 50
 
         with repo.lock():
             bundle = [None, None]
             orig_quiet = repo.ui.quiet
             try:
                 repo.ui.quiet = True
                 with open(fname, mode="rb") as f:
 
                     def noop_report(*args, **kwargs):
                         pass
 
                     def setup():
                         gen, tr = bundle
                         if tr is not None:
                             tr.abort()
                         bundle[:] = [None, None]
                         f.seek(0)
                         bundle[0] = exchange.readbundle(ui, f, fname)
                         bundle[1] = repo.transaction(b'perf::unbundle')
                         # silence the transaction
                         bundle[1]._report = noop_report
 
                     def apply():
                         gen, tr = bundle
                         bundle2.applybundle(
                             repo,
                             gen,
                             tr,
                             source=b'perf::unbundle',
                             url=fname,
                         )
 
                     timer, fm = gettimer(ui, opts)
                     timer(apply, setup=setup)
                     fm.end()
             finally:
                 repo.ui.quiet == orig_quiet
                 gen, tr = bundle
                 if tr is not None:
                     tr.abort()
     finally:
         if old_max_inline is not None:
             mercurial.revlog._maxinline = old_max_inline
 
 
 @command(
     b'perf::unidiff|perfunidiff',
     revlogopts
     + formatteropts
     + [
         (
             b'',
             b'count',
             1,
             b'number of revisions to test (when using --startrev)',
         ),
         (b'', b'alldata', False, b'test unidiffs for all associated revisions'),
     ],
     b'-c|-m|FILE REV',
 )
 def perfunidiff(ui, repo, file_, rev=None, count=None, **opts):
     """benchmark a unified diff between revisions
 
     This doesn't include any copy tracing - it's just a unified diff
     of the texts.
 
     By default, benchmark a diff between its delta parent and itself.
 
     With ``--count``, benchmark diffs between delta parents and self for N
     revisions starting at the specified revision.
 
     With ``--alldata``, assume the requested revision is a changeset and
     measure diffs for all changes related to that changeset (manifest
     and filelogs).
     """
     opts = _byteskwargs(opts)
     if opts[b'alldata']:
         opts[b'changelog'] = True
 
     if opts.get(b'changelog') or opts.get(b'manifest'):
         file_, rev = None, file_
     elif rev is None:
         raise error.CommandError(b'perfunidiff', b'invalid arguments')
 
     textpairs = []
 
     r = cmdutil.openrevlog(repo, b'perfunidiff', file_, opts)
 
     startrev = r.rev(r.lookup(rev))
     for rev in range(startrev, min(startrev + count, len(r) - 1)):
         if opts[b'alldata']:
             # Load revisions associated with changeset.
             ctx = repo[rev]
             mtext = _manifestrevision(repo, ctx.manifestnode())
             for pctx in ctx.parents():
                 pman = _manifestrevision(repo, pctx.manifestnode())
                 textpairs.append((pman, mtext))
 
             # Load filelog revisions by iterating manifest delta.
             man = ctx.manifest()
             pman = ctx.p1().manifest()
             for filename, change in pman.diff(man).items():
                 fctx = repo.file(filename)
                 f1 = fctx.revision(change[0][0] or -1)
                 f2 = fctx.revision(change[1][0] or -1)
                 textpairs.append((f1, f2))
         else:
             dp = r.deltaparent(rev)
             textpairs.append((r.revision(dp), r.revision(rev)))
 
     def d():
         for left, right in textpairs:
             # The date strings don't matter, so we pass empty strings.
             headerlines, hunks = mdiff.unidiff(
                 left, b'', right, b'', b'left', b'right', binary=False
             )
             # consume iterators in roughly the way patch.py does
             b'\n'.join(headerlines)
             b''.join(sum((list(hlines) for hrange, hlines in hunks), []))
 
     timer, fm = gettimer(ui, opts)
     timer(d)
     fm.end()
 
 
 @command(b'perf::diffwd|perfdiffwd', formatteropts)
 def perfdiffwd(ui, repo, **opts):
     """Profile diff of working directory changes"""
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     options = {
         'w': 'ignore_all_space',
         'b': 'ignore_space_change',
         'B': 'ignore_blank_lines',
     }
 
     for diffopt in ('', 'w', 'b', 'B', 'wB'):
         opts = {options[c]: b'1' for c in diffopt}
 
         def d():
             ui.pushbuffer()
             commands.diff(ui, repo, **opts)
             ui.popbuffer()
 
         diffopt = diffopt.encode('ascii')
         title = b'diffopts: %s' % (diffopt and (b'-' + diffopt) or b'none')
         timer(d, title=title)
     fm.end()
 
 
 @command(
     b'perf::revlogindex|perfrevlogindex',
     revlogopts + formatteropts,
     b'-c|-m|FILE',
 )
 def perfrevlogindex(ui, repo, file_=None, **opts):
     """Benchmark operations against a revlog index.
 
     This tests constructing a revlog instance, reading index data,
     parsing index data, and performing various operations related to
     index data.
     """
 
     opts = _byteskwargs(opts)
 
     rl = cmdutil.openrevlog(repo, b'perfrevlogindex', file_, opts)
 
     opener = getattr(rl, 'opener')  # trick linter
     # compat with hg <= 5.8
     radix = getattr(rl, 'radix', None)
     indexfile = getattr(rl, '_indexfile', None)
     if indexfile is None:
         # compatibility with <= hg-5.8
         indexfile = getattr(rl, 'indexfile')
     data = opener.read(indexfile)
 
     header = struct.unpack(b'>I', data[0:4])[0]
     version = header & 0xFFFF
     if version == 1:
         inline = header & (1 << 16)
     else:
         raise error.Abort(b'unsupported revlog version: %d' % version)
 
     parse_index_v1 = getattr(mercurial.revlog, 'parse_index_v1', None)
     if parse_index_v1 is None:
         parse_index_v1 = mercurial.revlog.revlogio().parseindex
 
     rllen = len(rl)
 
     node0 = rl.node(0)
     node25 = rl.node(rllen // 4)
     node50 = rl.node(rllen // 2)
     node75 = rl.node(rllen // 4 * 3)
     node100 = rl.node(rllen - 1)
 
     allrevs = range(rllen)
     allrevsrev = list(reversed(allrevs))
     allnodes = [rl.node(rev) for rev in range(rllen)]
     allnodesrev = list(reversed(allnodes))
 
     def constructor():
         if radix is not None:
             revlog(opener, radix=radix)
         else:
             # hg <= 5.8
             revlog(opener, indexfile=indexfile)
 
     def read():
         with opener(indexfile) as fh:
             fh.read()
 
     def parseindex():
         parse_index_v1(data, inline)
 
     def getentry(revornode):
         index = parse_index_v1(data, inline)[0]
         index[revornode]
 
     def getentries(revs, count=1):
         index = parse_index_v1(data, inline)[0]
 
         for i in range(count):
             for rev in revs:
                 index[rev]
 
     def resolvenode(node):
         index = parse_index_v1(data, inline)[0]
         rev = getattr(index, 'rev', None)
         if rev is None:
             nodemap = getattr(parse_index_v1(data, inline)[0], 'nodemap', None)
             # This only works for the C code.
             if nodemap is None:
                 return
             rev = nodemap.__getitem__
 
         try:
             rev(node)
         except error.RevlogError:
             pass
 
     def resolvenodes(nodes, count=1):
         index = parse_index_v1(data, inline)[0]
         rev = getattr(index, 'rev', None)
         if rev is None:
             nodemap = getattr(parse_index_v1(data, inline)[0], 'nodemap', None)
             # This only works for the C code.
             if nodemap is None:
                 return
             rev = nodemap.__getitem__
 
         for i in range(count):
             for node in nodes:
                 try:
                     rev(node)
                 except error.RevlogError:
                     pass
 
     benches = [
         (constructor, b'revlog constructor'),
         (read, b'read'),
         (parseindex, b'create index object'),
         (lambda: getentry(0), b'retrieve index entry for rev 0'),
         (lambda: resolvenode(b'a' * 20), b'look up missing node'),
         (lambda: resolvenode(node0), b'look up node at rev 0'),
         (lambda: resolvenode(node25), b'look up node at 1/4 len'),
         (lambda: resolvenode(node50), b'look up node at 1/2 len'),
         (lambda: resolvenode(node75), b'look up node at 3/4 len'),
         (lambda: resolvenode(node100), b'look up node at tip'),
         # 2x variation is to measure caching impact.
         (lambda: resolvenodes(allnodes), b'look up all nodes (forward)'),
         (lambda: resolvenodes(allnodes, 2), b'look up all nodes 2x (forward)'),
         (lambda: resolvenodes(allnodesrev), b'look up all nodes (reverse)'),
         (
             lambda: resolvenodes(allnodesrev, 2),
             b'look up all nodes 2x (reverse)',
         ),
         (lambda: getentries(allrevs), b'retrieve all index entries (forward)'),
         (
             lambda: getentries(allrevs, 2),
             b'retrieve all index entries 2x (forward)',
         ),
         (
             lambda: getentries(allrevsrev),
             b'retrieve all index entries (reverse)',
         ),
         (
             lambda: getentries(allrevsrev, 2),
             b'retrieve all index entries 2x (reverse)',
         ),
     ]
 
     for fn, title in benches:
         timer, fm = gettimer(ui, opts)
         timer(fn, title=title)
         fm.end()
 
 
 @command(
     b'perf::revlogrevisions|perfrevlogrevisions',
     revlogopts
     + formatteropts
     + [
         (b'd', b'dist', 100, b'distance between the revisions'),
         (b's', b'startrev', 0, b'revision to start reading at'),
         (b'', b'reverse', False, b'read in reverse'),
     ],
     b'-c|-m|FILE',
 )
 def perfrevlogrevisions(
     ui, repo, file_=None, startrev=0, reverse=False, **opts
 ):
     """Benchmark reading a series of revisions from a revlog.
 
     By default, we read every ``-d/--dist`` revision from 0 to tip of
     the specified revlog.
 
     The start revision can be defined via ``-s/--startrev``.
     """
     opts = _byteskwargs(opts)
 
     rl = cmdutil.openrevlog(repo, b'perfrevlogrevisions', file_, opts)
     rllen = getlen(ui)(rl)
 
     if startrev < 0:
         startrev = rllen + startrev
 
     def d():
         rl.clearcaches()
 
         beginrev = startrev
         endrev = rllen
         dist = opts[b'dist']
 
         if reverse:
             beginrev, endrev = endrev - 1, beginrev - 1
             dist = -1 * dist
 
         for x in _xrange(beginrev, endrev, dist):
             # Old revisions don't support passing int.
             n = rl.node(x)
             rl.revision(n)
 
     timer, fm = gettimer(ui, opts)
     timer(d)
     fm.end()
 
 
 @command(
     b'perf::revlogwrite|perfrevlogwrite',
     revlogopts
     + formatteropts
     + [
         (b's', b'startrev', 1000, b'revision to start writing at'),
         (b'', b'stoprev', -1, b'last revision to write'),
         (b'', b'count', 3, b'number of passes to perform'),
         (b'', b'details', False, b'print timing for every revisions tested'),
         (b'', b'source', b'full', b'the kind of data feed in the revlog'),
         (b'', b'lazydeltabase', True, b'try the provided delta first'),
         (b'', b'clear-caches', True, b'clear revlog cache between calls'),
     ],
     b'-c|-m|FILE',
 )
 def perfrevlogwrite(ui, repo, file_=None, startrev=1000, stoprev=-1, **opts):
     """Benchmark writing a series of revisions to a revlog.
 
     Possible source values are:
     * `full`: add from a full text (default).
     * `parent-1`: add from a delta to the first parent
     * `parent-2`: add from a delta to the second parent if it exists
                   (use a delta from the first parent otherwise)
     * `parent-smallest`: add from the smallest delta (either p1 or p2)
     * `storage`: add from the existing precomputed deltas
 
     Note: This performance command measures performance in a custom way. As a
     result some of the global configuration of the 'perf' command does not
     apply to it:
 
     * ``pre-run``: disabled
 
     * ``profile-benchmark``: disabled
 
     * ``run-limits``: disabled use --count instead
     """
     opts = _byteskwargs(opts)
 
     rl = cmdutil.openrevlog(repo, b'perfrevlogwrite', file_, opts)
     rllen = getlen(ui)(rl)
     if startrev < 0:
         startrev = rllen + startrev
     if stoprev < 0:
         stoprev = rllen + stoprev
 
     lazydeltabase = opts['lazydeltabase']
     source = opts['source']
     clearcaches = opts['clear_caches']
     validsource = (
         b'full',
         b'parent-1',
         b'parent-2',
         b'parent-smallest',
         b'storage',
     )
     if source not in validsource:
         raise error.Abort('invalid source type: %s' % source)
 
     ### actually gather results
     count = opts['count']
     if count <= 0:
         raise error.Abort('invalide run count: %d' % count)
     allresults = []
     for c in range(count):
         timing = _timeonewrite(
             ui,
             rl,
             source,
             startrev,
             stoprev,
             c + 1,
             lazydeltabase=lazydeltabase,
             clearcaches=clearcaches,
         )
         allresults.append(timing)
 
     ### consolidate the results in a single list
     results = []
     for idx, (rev, t) in enumerate(allresults[0]):
         ts = [t]
         for other in allresults[1:]:
             orev, ot = other[idx]
             assert orev == rev
             ts.append(ot)
         results.append((rev, ts))
     resultcount = len(results)
 
     ### Compute and display relevant statistics
 
     # get a formatter
     fm = ui.formatter(b'perf', opts)
     displayall = ui.configbool(b"perf", b"all-timing", True)
 
     # print individual details if requested
     if opts['details']:
         for idx, item in enumerate(results, 1):
             rev, data = item
             title = 'revisions #%d of %d, rev %d' % (idx, resultcount, rev)
             formatone(fm, data, title=title, displayall=displayall)
 
     # sorts results by median time
     results.sort(key=lambda x: sorted(x[1])[len(x[1]) // 2])
     # list of (name, index) to display)
     relevants = [
         ("min", 0),
         ("10%", resultcount * 10 // 100),
         ("25%", resultcount * 25 // 100),
         ("50%", resultcount * 70 // 100),
         ("75%", resultcount * 75 // 100),
         ("90%", resultcount * 90 // 100),
         ("95%", resultcount * 95 // 100),
         ("99%", resultcount * 99 // 100),
         ("99.9%", resultcount * 999 // 1000),
         ("99.99%", resultcount * 9999 // 10000),
         ("99.999%", resultcount * 99999 // 100000),
         ("max", -1),
     ]
     if not ui.quiet:
         for name, idx in relevants:
             data = results[idx]
             title = '%s of %d, rev %d' % (name, resultcount, data[0])
             formatone(fm, data[1], title=title, displayall=displayall)
 
     # XXX summing that many float will not be very precise, we ignore this fact
     # for now
     totaltime = []
     for item in allresults:
         totaltime.append(
             (
                 sum(x[1][0] for x in item),
                 sum(x[1][1] for x in item),
                 sum(x[1][2] for x in item),
             )
         )
     formatone(
         fm,
         totaltime,
         title="total time (%d revs)" % resultcount,
         displayall=displayall,
     )
     fm.end()
 
 
 class _faketr:
     def add(s, x, y, z=None):
         return None
 
 
 def _timeonewrite(
     ui,
     orig,
     source,
     startrev,
     stoprev,
     runidx=None,
     lazydeltabase=True,
     clearcaches=True,
 ):
     timings = []
     tr = _faketr()
     with _temprevlog(ui, orig, startrev) as dest:
         dest._lazydeltabase = lazydeltabase
         revs = list(orig.revs(startrev, stoprev))
         total = len(revs)
         topic = 'adding'
         if runidx is not None:
             topic += ' (run #%d)' % runidx
         # Support both old and new progress API
         if util.safehasattr(ui, 'makeprogress'):
             progress = ui.makeprogress(topic, unit='revs', total=total)
 
             def updateprogress(pos):
                 progress.update(pos)
 
             def completeprogress():
                 progress.complete()
 
         else:
 
             def updateprogress(pos):
                 ui.progress(topic, pos, unit='revs', total=total)
 
             def completeprogress():
                 ui.progress(topic, None, unit='revs', total=total)
 
         for idx, rev in enumerate(revs):
             updateprogress(idx)
             addargs, addkwargs = _getrevisionseed(orig, rev, tr, source)
             if clearcaches:
                 dest.index.clearcaches()
                 dest.clearcaches()
             with timeone() as r:
                 dest.addrawrevision(*addargs, **addkwargs)
             timings.append((rev, r[0]))
         updateprogress(total)
         completeprogress()
     return timings
 
 
 def _getrevisionseed(orig, rev, tr, source):
     from mercurial.node import nullid
 
     linkrev = orig.linkrev(rev)
     node = orig.node(rev)
     p1, p2 = orig.parents(node)
     flags = orig.flags(rev)
     cachedelta = None
     text = None
 
     if source == b'full':
         text = orig.revision(rev)
     elif source == b'parent-1':
         baserev = orig.rev(p1)
         cachedelta = (baserev, orig.revdiff(p1, rev))
     elif source == b'parent-2':
         parent = p2
         if p2 == nullid:
             parent = p1
         baserev = orig.rev(parent)
         cachedelta = (baserev, orig.revdiff(parent, rev))
     elif source == b'parent-smallest':
         p1diff = orig.revdiff(p1, rev)
         parent = p1
         diff = p1diff
         if p2 != nullid:
             p2diff = orig.revdiff(p2, rev)
             if len(p1diff) > len(p2diff):
                 parent = p2
                 diff = p2diff
         baserev = orig.rev(parent)
         cachedelta = (baserev, diff)
     elif source == b'storage':
         baserev = orig.deltaparent(rev)
         cachedelta = (baserev, orig.revdiff(orig.node(baserev), rev))
 
     return (
         (text, tr, linkrev, p1, p2),
         {'node': node, 'flags': flags, 'cachedelta': cachedelta},
     )
 
 
 @contextlib.contextmanager
 def _temprevlog(ui, orig, truncaterev):
     from mercurial import vfs as vfsmod
 
     if orig._inline:
         raise error.Abort('not supporting inline revlog (yet)')
     revlogkwargs = {}
     k = 'upperboundcomp'
     if util.safehasattr(orig, k):
         revlogkwargs[k] = getattr(orig, k)
 
     indexfile = getattr(orig, '_indexfile', None)
     if indexfile is None:
         # compatibility with <= hg-5.8
         indexfile = getattr(orig, 'indexfile')
     origindexpath = orig.opener.join(indexfile)
 
     datafile = getattr(orig, '_datafile', getattr(orig, 'datafile'))
     origdatapath = orig.opener.join(datafile)
     radix = b'revlog'
     indexname = b'revlog.i'
     dataname = b'revlog.d'
 
     tmpdir = tempfile.mkdtemp(prefix='tmp-hgperf-')
     try:
         # copy the data file in a temporary directory
         ui.debug('copying data in %s\n' % tmpdir)
         destindexpath = os.path.join(tmpdir, 'revlog.i')
         destdatapath = os.path.join(tmpdir, 'revlog.d')
         shutil.copyfile(origindexpath, destindexpath)
         shutil.copyfile(origdatapath, destdatapath)
 
         # remove the data we want to add again
         ui.debug('truncating data to be rewritten\n')
         with open(destindexpath, 'ab') as index:
             index.seek(0)
             index.truncate(truncaterev * orig._io.size)
         with open(destdatapath, 'ab') as data:
             data.seek(0)
             data.truncate(orig.start(truncaterev))
 
         # instantiate a new revlog from the temporary copy
         ui.debug('truncating adding to be rewritten\n')
         vfs = vfsmod.vfs(tmpdir)
         vfs.options = getattr(orig.opener, 'options', None)
 
         try:
             dest = revlog(vfs, radix=radix, **revlogkwargs)
         except TypeError:
             dest = revlog(
                 vfs, indexfile=indexname, datafile=dataname, **revlogkwargs
             )
         if dest._inline:
             raise error.Abort('not supporting inline revlog (yet)')
         # make sure internals are initialized
         dest.revision(len(dest) - 1)
         yield dest
         del dest, vfs
     finally:
         shutil.rmtree(tmpdir, True)
 
 
 @command(
     b'perf::revlogchunks|perfrevlogchunks',
     revlogopts
     + formatteropts
     + [
         (b'e', b'engines', b'', b'compression engines to use'),
         (b's', b'startrev', 0, b'revision to start at'),
     ],
     b'-c|-m|FILE',
 )
 def perfrevlogchunks(ui, repo, file_=None, engines=None, startrev=0, **opts):
     """Benchmark operations on revlog chunks.
 
     Logically, each revlog is a collection of fulltext revisions. However,
     stored within each revlog are "chunks" of possibly compressed data. This
     data needs to be read and decompressed or compressed and written.
 
     This command measures the time it takes to read+decompress and recompress
     chunks in a revlog. It effectively isolates I/O and compression performance.
     For measurements of higher-level operations like resolving revisions,
     see ``perfrevlogrevisions`` and ``perfrevlogrevision``.
     """
     opts = _byteskwargs(opts)
 
     rl = cmdutil.openrevlog(repo, b'perfrevlogchunks', file_, opts)
 
     # _chunkraw was renamed to _getsegmentforrevs.
     try:
         segmentforrevs = rl._getsegmentforrevs
     except AttributeError:
         segmentforrevs = rl._chunkraw
 
     # Verify engines argument.
     if engines:
         engines = {e.strip() for e in engines.split(b',')}
         for engine in engines:
             try:
                 util.compressionengines[engine]
             except KeyError:
                 raise error.Abort(b'unknown compression engine: %s' % engine)
     else:
         engines = []
         for e in util.compengines:
             engine = util.compengines[e]
             try:
                 if engine.available():
                     engine.revlogcompressor().compress(b'dummy')
                     engines.append(e)
             except NotImplementedError:
                 pass
 
     revs = list(rl.revs(startrev, len(rl) - 1))
 
     def rlfh(rl):
         if rl._inline:
             indexfile = getattr(rl, '_indexfile', None)
             if indexfile is None:
                 # compatibility with <= hg-5.8
                 indexfile = getattr(rl, 'indexfile')
             return getsvfs(repo)(indexfile)
         else:
             datafile = getattr(rl, 'datafile', getattr(rl, 'datafile'))
             return getsvfs(repo)(datafile)
 
     def doread():
         rl.clearcaches()
         for rev in revs:
             segmentforrevs(rev, rev)
 
     def doreadcachedfh():
         rl.clearcaches()
         fh = rlfh(rl)
         for rev in revs:
             segmentforrevs(rev, rev, df=fh)
 
     def doreadbatch():
         rl.clearcaches()
         segmentforrevs(revs[0], revs[-1])
 
     def doreadbatchcachedfh():
         rl.clearcaches()
         fh = rlfh(rl)
         segmentforrevs(revs[0], revs[-1], df=fh)
 
     def dochunk():
         rl.clearcaches()
         fh = rlfh(rl)
         for rev in revs:
             rl._chunk(rev, df=fh)
 
     chunks = [None]
 
     def dochunkbatch():
         rl.clearcaches()
         fh = rlfh(rl)
         # Save chunks as a side-effect.
         chunks[0] = rl._chunks(revs, df=fh)
 
     def docompress(compressor):
         rl.clearcaches()
 
         try:
             # Swap in the requested compression engine.
             oldcompressor = rl._compressor
             rl._compressor = compressor
             for chunk in chunks[0]:
                 rl.compress(chunk)
         finally:
             rl._compressor = oldcompressor
 
     benches = [
         (lambda: doread(), b'read'),
         (lambda: doreadcachedfh(), b'read w/ reused fd'),
         (lambda: doreadbatch(), b'read batch'),
         (lambda: doreadbatchcachedfh(), b'read batch w/ reused fd'),
         (lambda: dochunk(), b'chunk'),
         (lambda: dochunkbatch(), b'chunk batch'),
     ]
 
     for engine in sorted(engines):
         compressor = util.compengines[engine].revlogcompressor()
         benches.append(
             (
                 functools.partial(docompress, compressor),
                 b'compress w/ %s' % engine,
             )
         )
 
     for fn, title in benches:
         timer, fm = gettimer(ui, opts)
         timer(fn, title=title)
         fm.end()
 
 
 @command(
     b'perf::revlogrevision|perfrevlogrevision',
     revlogopts
     + formatteropts
     + [(b'', b'cache', False, b'use caches instead of clearing')],
     b'-c|-m|FILE REV',
 )
 def perfrevlogrevision(ui, repo, file_, rev=None, cache=None, **opts):
     """Benchmark obtaining a revlog revision.
 
     Obtaining a revlog revision consists of roughly the following steps:
 
     1. Compute the delta chain
     2. Slice the delta chain if applicable
     3. Obtain the raw chunks for that delta chain
     4. Decompress each raw chunk
     5. Apply binary patches to obtain fulltext
     6. Verify hash of fulltext
 
     This command measures the time spent in each of these phases.
     """
     opts = _byteskwargs(opts)
 
     if opts.get(b'changelog') or opts.get(b'manifest'):
         file_, rev = None, file_
     elif rev is None:
         raise error.CommandError(b'perfrevlogrevision', b'invalid arguments')
 
     r = cmdutil.openrevlog(repo, b'perfrevlogrevision', file_, opts)
 
     # _chunkraw was renamed to _getsegmentforrevs.
     try:
         segmentforrevs = r._getsegmentforrevs
     except AttributeError:
         segmentforrevs = r._chunkraw
 
     node = r.lookup(rev)
     rev = r.rev(node)
 
     def getrawchunks(data, chain):
         start = r.start
         length = r.length
         inline = r._inline
         try:
             iosize = r.index.entry_size
         except AttributeError:
             iosize = r._io.size
         buffer = util.buffer
 
         chunks = []
         ladd = chunks.append
         for idx, item in enumerate(chain):
             offset = start(item[0])
             bits = data[idx]
             for rev in item:
                 chunkstart = start(rev)
                 if inline:
                     chunkstart += (rev + 1) * iosize
                 chunklength = length(rev)
                 ladd(buffer(bits, chunkstart - offset, chunklength))
 
         return chunks
 
     def dodeltachain(rev):
         if not cache:
             r.clearcaches()
         r._deltachain(rev)
 
     def doread(chain):
         if not cache:
             r.clearcaches()
         for item in slicedchain:
             segmentforrevs(item[0], item[-1])
 
     def doslice(r, chain, size):
         for s in slicechunk(r, chain, targetsize=size):
             pass
 
     def dorawchunks(data, chain):
         if not cache:
             r.clearcaches()
         getrawchunks(data, chain)
 
     def dodecompress(chunks):
         decomp = r.decompress
         for chunk in chunks:
             decomp(chunk)
 
     def dopatch(text, bins):
         if not cache:
             r.clearcaches()
         mdiff.patches(text, bins)
 
     def dohash(text):
         if not cache:
             r.clearcaches()
         r.checkhash(text, node, rev=rev)
 
     def dorevision():
         if not cache:
             r.clearcaches()
         r.revision(node)
 
     try:
         from mercurial.revlogutils.deltas import slicechunk
     except ImportError:
         slicechunk = getattr(revlog, '_slicechunk', None)
 
     size = r.length(rev)
     chain = r._deltachain(rev)[0]
     if not getattr(r, '_withsparseread', False):
         slicedchain = (chain,)
     else:
         slicedchain = tuple(slicechunk(r, chain, targetsize=size))
     data = [segmentforrevs(seg[0], seg[-1])[1] for seg in slicedchain]
     rawchunks = getrawchunks(data, slicedchain)
     bins = r._chunks(chain)
     text = bytes(bins[0])
     bins = bins[1:]
     text = mdiff.patches(text, bins)
 
     benches = [
         (lambda: dorevision(), b'full'),
         (lambda: dodeltachain(rev), b'deltachain'),
         (lambda: doread(chain), b'read'),
     ]
 
     if getattr(r, '_withsparseread', False):
         slicing = (lambda: doslice(r, chain, size), b'slice-sparse-chain')
         benches.append(slicing)
 
     benches.extend(
         [
             (lambda: dorawchunks(data, slicedchain), b'rawchunks'),
             (lambda: dodecompress(rawchunks), b'decompress'),
             (lambda: dopatch(text, bins), b'patch'),
             (lambda: dohash(text), b'hash'),
         ]
     )
 
     timer, fm = gettimer(ui, opts)
     for fn, title in benches:
         timer(fn, title=title)
     fm.end()
 
 
 @command(
     b'perf::revset|perfrevset',
     [
         (b'C', b'clear', False, b'clear volatile cache between each call.'),
         (b'', b'contexts', False, b'obtain changectx for each revision'),
     ]
     + formatteropts,
     b"REVSET",
 )
 def perfrevset(ui, repo, expr, clear=False, contexts=False, **opts):
     """benchmark the execution time of a revset
 
     Use the --clean option if need to evaluate the impact of build volatile
     revisions set cache on the revset execution. Volatile cache hold filtered
     and obsolete related cache."""
     opts = _byteskwargs(opts)
 
     timer, fm = gettimer(ui, opts)
 
     def d():
         if clear:
             repo.invalidatevolatilesets()
         if contexts:
             for ctx in repo.set(expr):
                 pass
         else:
             for r in repo.revs(expr):
                 pass
 
     timer(d)
     fm.end()
 
 
 @command(
     b'perf::volatilesets|perfvolatilesets',
     [
         (b'', b'clear-obsstore', False, b'drop obsstore between each call.'),
     ]
     + formatteropts,
 )
 def perfvolatilesets(ui, repo, *names, **opts):
     """benchmark the computation of various volatile set
 
     Volatile set computes element related to filtering and obsolescence."""
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     repo = repo.unfiltered()
 
     def getobs(name):
         def d():
             repo.invalidatevolatilesets()
             if opts[b'clear_obsstore']:
                 clearfilecache(repo, b'obsstore')
             obsolete.getrevs(repo, name)
 
         return d
 
     allobs = sorted(obsolete.cachefuncs)
     if names:
         allobs = [n for n in allobs if n in names]
 
     for name in allobs:
         timer(getobs(name), title=name)
 
     def getfiltered(name):
         def d():
             repo.invalidatevolatilesets()
             if opts[b'clear_obsstore']:
                 clearfilecache(repo, b'obsstore')
             repoview.filterrevs(repo, name)
 
         return d
 
     allfilter = sorted(repoview.filtertable)
     if names:
         allfilter = [n for n in allfilter if n in names]
 
     for name in allfilter:
         timer(getfiltered(name), title=name)
     fm.end()
 
 
 @command(
     b'perf::branchmap|perfbranchmap',
     [
         (b'f', b'full', False, b'Includes build time of subset'),
         (
             b'',
             b'clear-revbranch',
             False,
             b'purge the revbranch cache between computation',
         ),
     ]
     + formatteropts,
 )
 def perfbranchmap(ui, repo, *filternames, **opts):
     """benchmark the update of a branchmap
 
     This benchmarks the full repo.branchmap() call with read and write disabled
     """
     opts = _byteskwargs(opts)
     full = opts.get(b"full", False)
     clear_revbranch = opts.get(b"clear_revbranch", False)
     timer, fm = gettimer(ui, opts)
 
     def getbranchmap(filtername):
         """generate a benchmark function for the filtername"""
         if filtername is None:
             view = repo
         else:
             view = repo.filtered(filtername)
         if util.safehasattr(view._branchcaches, '_per_filter'):
             filtered = view._branchcaches._per_filter
         else:
             # older versions
             filtered = view._branchcaches
 
         def d():
             if clear_revbranch:
                 repo.revbranchcache()._clear()
             if full:
                 view._branchcaches.clear()
             else:
                 filtered.pop(filtername, None)
             view.branchmap()
 
         return d
 
     # add filter in smaller subset to bigger subset
     possiblefilters = set(repoview.filtertable)
     if filternames:
         possiblefilters &= set(filternames)
     subsettable = getbranchmapsubsettable()
     allfilters = []
     while possiblefilters:
         for name in possiblefilters:
             subset = subsettable.get(name)
             if subset not in possiblefilters:
                 break
         else:
             assert False, b'subset cycle %s!' % possiblefilters
         allfilters.append(name)
         possiblefilters.remove(name)
 
     # warm the cache
     if not full:
         for name in allfilters:
             repo.filtered(name).branchmap()
     if not filternames or b'unfiltered' in filternames:
         # add unfiltered
         allfilters.append(None)
 
     if util.safehasattr(branchmap.branchcache, 'fromfile'):
         branchcacheread = safeattrsetter(branchmap.branchcache, b'fromfile')
         branchcacheread.set(classmethod(lambda *args: None))
     else:
         # older versions
         branchcacheread = safeattrsetter(branchmap, b'read')
         branchcacheread.set(lambda *args: None)
     branchcachewrite = safeattrsetter(branchmap.branchcache, b'write')
     branchcachewrite.set(lambda *args: None)
     try:
         for name in allfilters:
             printname = name
             if name is None:
                 printname = b'unfiltered'
             timer(getbranchmap(name), title=printname)
     finally:
         branchcacheread.restore()
         branchcachewrite.restore()
     fm.end()
 
 
 @command(
     b'perf::branchmapupdate|perfbranchmapupdate',
     [
         (b'', b'base', [], b'subset of revision to start from'),
         (b'', b'target', [], b'subset of revision to end with'),
         (b'', b'clear-caches', False, b'clear cache between each runs'),
     ]
     + formatteropts,
 )
 def perfbranchmapupdate(ui, repo, base=(), target=(), **opts):
     """benchmark branchmap update from for <base> revs to <target> revs
 
     If `--clear-caches` is passed, the following items will be reset before
     each update:
         * the changelog instance and associated indexes
         * the rev-branch-cache instance
 
     Examples:
 
        # update for the one last revision
        $ hg perfbranchmapupdate --base 'not tip' --target 'tip'
 
        $ update for change coming with a new branch
        $ hg perfbranchmapupdate --base 'stable' --target 'default'
     """
     from mercurial import branchmap
     from mercurial import repoview
 
     opts = _byteskwargs(opts)
     timer, fm = gettimer(ui, opts)
     clearcaches = opts[b'clear_caches']
     unfi = repo.unfiltered()
     x = [None]  # used to pass data between closure
 
     # we use a `list` here to avoid possible side effect from smartset
     baserevs = list(scmutil.revrange(repo, base))
     targetrevs = list(scmutil.revrange(repo, target))
     if not baserevs:
         raise error.Abort(b'no revisions selected for --base')
     if not targetrevs:
         raise error.Abort(b'no revisions selected for --target')
 
     # make sure the target branchmap also contains the one in the base
     targetrevs = list(set(baserevs) | set(targetrevs))
     targetrevs.sort()
 
     cl = repo.changelog
     allbaserevs = list(cl.ancestors(baserevs, inclusive=True))
     allbaserevs.sort()
     alltargetrevs = frozenset(cl.ancestors(targetrevs, inclusive=True))
 
     newrevs = list(alltargetrevs.difference(allbaserevs))
     newrevs.sort()
 
     allrevs = frozenset(unfi.changelog.revs())
     basefilterrevs = frozenset(allrevs.difference(allbaserevs))
     targetfilterrevs = frozenset(allrevs.difference(alltargetrevs))
 
     def basefilter(repo, visibilityexceptions=None):
         return basefilterrevs
 
     def targetfilter(repo, visibilityexceptions=None):
         return targetfilterrevs
 
     msg = b'benchmark of branchmap with %d revisions with %d new ones\n'
     ui.status(msg % (len(allbaserevs), len(newrevs)))
     if targetfilterrevs:
         msg = b'(%d revisions still filtered)\n'
         ui.status(msg % len(targetfilterrevs))
 
     try:
         repoview.filtertable[b'__perf_branchmap_update_base'] = basefilter
         repoview.filtertable[b'__perf_branchmap_update_target'] = targetfilter
 
         baserepo = repo.filtered(b'__perf_branchmap_update_base')
         targetrepo = repo.filtered(b'__perf_branchmap_update_target')
 
         # try to find an existing branchmap to reuse
         subsettable = getbranchmapsubsettable()
         candidatefilter = subsettable.get(None)
         while candidatefilter is not None:
             candidatebm = repo.filtered(candidatefilter).branchmap()
             if candidatebm.validfor(baserepo):
                 filtered = repoview.filterrevs(repo, candidatefilter)
                 missing = [r for r in allbaserevs if r in filtered]
                 base = candidatebm.copy()
                 base.update(baserepo, missing)
                 break
             candidatefilter = subsettable.get(candidatefilter)
         else:
             # no suitable subset where found
             base = branchmap.branchcache()
             base.update(baserepo, allbaserevs)
 
         def setup():
             x[0] = base.copy()
             if clearcaches:
                 unfi._revbranchcache = None
                 clearchangelog(repo)
 
         def bench():
             x[0].update(targetrepo, newrevs)
 
         timer(bench, setup=setup)
         fm.end()
     finally:
         repoview.filtertable.pop(b'__perf_branchmap_update_base', None)
         repoview.filtertable.pop(b'__perf_branchmap_update_target', None)
 
 
 @command(
     b'perf::branchmapload|perfbranchmapload',
     [
         (b'f', b'filter', b'', b'Specify repoview filter'),
         (b'', b'list', False, b'List brachmap filter caches'),
         (b'', b'clear-revlogs', False, b'refresh changelog and manifest'),
     ]
     + formatteropts,
 )
 def perfbranchmapload(ui, repo, filter=b'', list=False, **opts):
     """benchmark reading the branchmap"""
     opts = _byteskwargs(opts)
     clearrevlogs = opts[b'clear_revlogs']
 
     if list:
         for name, kind, st in repo.cachevfs.readdir(stat=True):
             if name.startswith(b'branch2'):
                 filtername = name.partition(b'-')[2] or b'unfiltered'
                 ui.status(
                     b'%s - %s\n' % (filtername, util.bytecount(st.st_size))
                 )
         return
     if not filter:
         filter = None
     subsettable = getbranchmapsubsettable()
     if filter is None:
         repo = repo.unfiltered()
     else:
         repo = repoview.repoview(repo, filter)
 
     repo.branchmap()  # make sure we have a relevant, up to date branchmap
 
     try:
         fromfile = branchmap.branchcache.fromfile
     except AttributeError:
         # older versions
         fromfile = branchmap.read
 
     currentfilter = filter
     # try once without timer, the filter may not be cached
     while fromfile(repo) is None:
         currentfilter = subsettable.get(currentfilter)
         if currentfilter is None:
             raise error.Abort(
                 b'No branchmap cached for %s repo' % (filter or b'unfiltered')
             )
         repo = repo.filtered(currentfilter)
     timer, fm = gettimer(ui, opts)
 
     def setup():
         if clearrevlogs:
             clearchangelog(repo)
 
     def bench():
         fromfile(repo)
 
     timer(bench, setup=setup)
     fm.end()
 
 
 @command(b'perf::loadmarkers|perfloadmarkers')
 def perfloadmarkers(ui, repo):
     """benchmark the time to parse the on-disk markers for a repo
 
     Result is the number of markers in the repo."""
     timer, fm = gettimer(ui)
     svfs = getsvfs(repo)
     timer(lambda: len(obsolete.obsstore(repo, svfs)))
     fm.end()
 
 
 @command(
     b'perf::lrucachedict|perflrucachedict',
     formatteropts
     + [
         (b'', b'costlimit', 0, b'maximum total cost of items in cache'),
         (b'', b'mincost', 0, b'smallest cost of items in cache'),
         (b'', b'maxcost', 100, b'maximum cost of items in cache'),
         (b'', b'size', 4, b'size of cache'),
         (b'', b'gets', 10000, b'number of key lookups'),
         (b'', b'sets', 10000, b'number of key sets'),
         (b'', b'mixed', 10000, b'number of mixed mode operations'),
         (
             b'',
             b'mixedgetfreq',
             50,
             b'frequency of get vs set ops in mixed mode',
         ),
     ],
     norepo=True,
 )
 def perflrucache(
     ui,
     mincost=0,
     maxcost=100,
     costlimit=0,
     size=4,
     gets=10000,
     sets=10000,
     mixed=10000,
     mixedgetfreq=50,
     **opts
 ):
     opts = _byteskwargs(opts)
 
     def doinit():
         for i in _xrange(10000):
             util.lrucachedict(size)
 
     costrange = list(range(mincost, maxcost + 1))
 
     values = []
     for i in _xrange(size):
         values.append(random.randint(0, _maxint))
 
     # Get mode fills the cache and tests raw lookup performance with no
     # eviction.
     getseq = []
     for i in _xrange(gets):
         getseq.append(random.choice(values))
 
     def dogets():
         d = util.lrucachedict(size)
         for v in values:
             d[v] = v
         for key in getseq:
             value = d[key]
             value  # silence pyflakes warning
 
     def dogetscost():
         d = util.lrucachedict(size, maxcost=costlimit)
         for i, v in enumerate(values):
             d.insert(v, v, cost=costs[i])
         for key in getseq:
             try:
                 value = d[key]
                 value  # silence pyflakes warning
             except KeyError:
                 pass
 
     # Set mode tests insertion speed with cache eviction.
     setseq = []
     costs = []
     for i in _xrange(sets):
         setseq.append(random.randint(0, _maxint))
         costs.append(random.choice(costrange))
 
     def doinserts():
         d = util.lrucachedict(size)
         for v in setseq:
             d.insert(v, v)
 
     def doinsertscost():
         d = util.lrucachedict(size, maxcost=costlimit)
         for i, v in enumerate(setseq):
             d.insert(v, v, cost=costs[i])
 
     def dosets():
         d = util.lrucachedict(size)
         for v in setseq:
             d[v] = v
 
     # Mixed mode randomly performs gets and sets with eviction.
     mixedops = []
     for i in _xrange(mixed):
         r = random.randint(0, 100)
         if r < mixedgetfreq:
             op = 0
         else:
             op = 1
 
         mixedops.append(
             (op, random.randint(0, size * 2), random.choice(costrange))
         )
 
     def domixed():
         d = util.lrucachedict(size)
 
         for op, v, cost in mixedops:
             if op == 0:
                 try:
                     d[v]
                 except KeyError:
                     pass
             else:
                 d[v] = v
 
     def domixedcost():
         d = util.lrucachedict(size, maxcost=costlimit)
 
         for op, v, cost in mixedops:
             if op == 0:
                 try:
                     d[v]
                 except KeyError:
                     pass
             else:
                 d.insert(v, v, cost=cost)
 
     benches = [
         (doinit, b'init'),
     ]
 
     if costlimit:
         benches.extend(
             [
                 (dogetscost, b'gets w/ cost limit'),
                 (doinsertscost, b'inserts w/ cost limit'),
                 (domixedcost, b'mixed w/ cost limit'),
             ]
         )
     else:
         benches.extend(
             [
                 (dogets, b'gets'),
                 (doinserts, b'inserts'),
                 (dosets, b'sets'),
                 (domixed, b'mixed'),
             ]
         )
 
     for fn, title in benches:
         timer, fm = gettimer(ui, opts)
         timer(fn, title=title)
         fm.end()
 
 
 @command(
     b'perf::write|perfwrite',
     formatteropts
     + [
         (b'', b'write-method', b'write', b'ui write method'),
         (b'', b'nlines', 100, b'number of lines'),
         (b'', b'nitems', 100, b'number of items (per line)'),
         (b'', b'item', b'x', b'item that is written'),
         (b'', b'batch-line', None, b'pass whole line to write method at once'),
         (b'', b'flush-line', None, b'flush after each line'),
     ],
 )
 def perfwrite(ui, repo, **opts):
     """microbenchmark ui.write (and others)"""
     opts = _byteskwargs(opts)
 
     write = getattr(ui, _sysstr(opts[b'write_method']))
     nlines = int(opts[b'nlines'])
     nitems = int(opts[b'nitems'])
     item = opts[b'item']
     batch_line = opts.get(b'batch_line')
     flush_line = opts.get(b'flush_line')
 
     if batch_line:
         line = item * nitems + b'\n'
 
     def benchmark():
         for i in pycompat.xrange(nlines):
             if batch_line:
                 write(line)
             else:
                 for i in pycompat.xrange(nitems):
                     write(item)
                 write(b'\n')
             if flush_line:
                 ui.flush()
         ui.flush()
 
     timer, fm = gettimer(ui, opts)
     timer(benchmark)
     fm.end()
 
 
 def uisetup(ui):
     if util.safehasattr(cmdutil, b'openrevlog') and not util.safehasattr(
         commands, b'debugrevlogopts'
     ):
         # for "historical portability":
         # In this case, Mercurial should be 1.9 (or a79fea6b3e77) -
         # 3.7 (or 5606f7d0d063). Therefore, '--dir' option for
         # openrevlog() should cause failure, because it has been
         # available since 3.5 (or 49c583ca48c4).
         def openrevlog(orig, repo, cmd, file_, opts):
             if opts.get(b'dir') and not util.safehasattr(repo, b'dirlog'):
                 raise error.Abort(
                     b"This version doesn't support --dir option",
                     hint=b"use 3.5 or later",
                 )
             return orig(repo, cmd, file_, opts)
 
         name = _sysstr(b'openrevlog')
         extensions.wrapfunction(cmdutil, name, openrevlog)
 
 
 @command(
     b'perf::progress|perfprogress',
     formatteropts
     + [
         (b'', b'topic', b'topic', b'topic for progress messages'),
         (b'c', b'total', 1000000, b'total value we are progressing to'),
     ],
     norepo=True,
 )
 def perfprogress(ui, topic=None, total=None, **opts):
     """printing of progress bars"""
     opts = _byteskwargs(opts)
 
     timer, fm = gettimer(ui, opts)
 
     def doprogress():
         with ui.makeprogress(topic, total=total) as progress:
             for i in _xrange(total):
                 progress.increment()
 
     timer(doprogress)
     fm.end()

hgext/blackbox.py

@@ -1,207 +1,211 b''
 # blackbox.py - log repository events to a file for post-mortem debugging
 #
 # Copyright 2010 Nicolas Dumazet
 # Copyright 2013 Facebook, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 """log repository events to a blackbox for debugging
 
 Logs event information to .hg/blackbox.log to help debug and diagnose problems.
 The events that get logged can be configured via the blackbox.track and
 blackbox.ignore config keys.
 
 Examples::
 
   [blackbox]
   track = *
   ignore = pythonhook
   # dirty is *EXPENSIVE* (slow);
   # each log entry indicates `+` if the repository is dirty, like :hg:`id`.
   dirty = True
   # record the source of log messages
   logsource = True
 
   [blackbox]
   track = command, commandfinish, commandexception, exthook, pythonhook
 
   [blackbox]
   track = incoming
 
   [blackbox]
   # limit the size of a log file
   maxsize = 1.5 MB
   # rotate up to N log files when the current one gets too big
   maxfiles = 3
 
   [blackbox]
   # Include microseconds in log entries with %f (see Python function
   # datetime.datetime.strftime)
   date-format = %Y-%m-%d @ %H:%M:%S.%f
 
 """
 
 
 import re
 
 from mercurial.i18n import _
 from mercurial.node import hex
 
 from mercurial import (
     encoding,
     loggingutil,
     registrar,
 )
 from mercurial.utils import (
     dateutil,
     procutil,
 )
 
 # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
 testedwith = b'ships-with-hg-core'
 
 cmdtable = {}
 command = registrar.command(cmdtable)
 
 _lastlogger = loggingutil.proxylogger()
 
 
 class blackboxlogger:
     def __init__(self, ui, repo):
         self._repo = repo
         self._trackedevents = set(ui.configlist(b'blackbox', b'track'))
         self._ignoredevents = set(ui.configlist(b'blackbox', b'ignore'))
         self._maxfiles = ui.configint(b'blackbox', b'maxfiles')
         self._maxsize = ui.configbytes(b'blackbox', b'maxsize')
         self._inlog = False
 
     def tracked(self, event):
         return (
             b'*' in self._trackedevents and event not in self._ignoredevents
         ) or event in self._trackedevents
 
     def log(self, ui, event, msg, opts):
         # self._log() -> ctx.dirty() may create new subrepo instance, which
         # ui is derived from baseui. So the recursion guard in ui.log()
         # doesn't work as it's local to the ui instance.
         if self._inlog:
             return
         self._inlog = True
         try:
             self._log(ui, event, msg, opts)
         finally:
             self._inlog = False
 
     def _log(self, ui, event, msg, opts):
         default = ui.configdate(b'devel', b'default-date')
         dateformat = ui.config(b'blackbox', b'date-format')
+        debug_to_stderr = ui.configbool(b'blackbox', b'debug.to-stderr')
         if dateformat:
             date = dateutil.datestr(default, dateformat)
         else:
             # We want to display milliseconds (more precision seems
             # unnecessary).  Since %.3f is not supported, use %f and truncate
             # microseconds.
             date = dateutil.datestr(default, b'%Y-%m-%d %H:%M:%S.%f')[:-3]
         user = procutil.getuser()
         pid = b'%d' % procutil.getpid()
         changed = b''
         ctx = self._repo[None]
         parents = ctx.parents()
         rev = b'+'.join([hex(p.node()) for p in parents])
         if ui.configbool(b'blackbox', b'dirty') and ctx.dirty(
             missing=True, merge=False, branch=False
         ):
             changed = b'+'
         if ui.configbool(b'blackbox', b'logsource'):
             src = b' [%s]' % event
         else:
             src = b''
         try:
             fmt = b'%s %s @%s%s (%s)%s> %s'
             args = (date, user, rev, changed, pid, src, msg)
             with loggingutil.openlogfile(
                 ui,
                 self._repo.vfs,
                 name=b'blackbox.log',
                 maxfiles=self._maxfiles,
                 maxsize=self._maxsize,
             ) as fp:
-                fp.write(fmt % args)
+                msg = fmt % args
+                fp.write(msg)
+                if debug_to_stderr:
+                    ui.write_err(msg)
         except (IOError, OSError) as err:
             # deactivate this to avoid failed logging again
             self._trackedevents.clear()
             ui.debug(
                 b'warning: cannot write to blackbox.log: %s\n'
                 % encoding.strtolocal(err.strerror)
             )
             return
         _lastlogger.logger = self
 
 
 def uipopulate(ui):
     ui.setlogger(b'blackbox', _lastlogger)
 
 
 def reposetup(ui, repo):
     # During 'hg pull' a httppeer repo is created to represent the remote repo.
     # It doesn't have a .hg directory to put a blackbox in, so we don't do
     # the blackbox setup for it.
     if not repo.local():
         return
 
     # Since blackbox.log is stored in the repo directory, the logger should be
     # instantiated per repository.
     logger = blackboxlogger(ui, repo)
     ui.setlogger(b'blackbox', logger)
 
     # Set _lastlogger even if ui.log is not called. This gives blackbox a
     # fallback place to log
     if _lastlogger.logger is None:
         _lastlogger.logger = logger
 
     repo._wlockfreeprefix.add(b'blackbox.log')
 
 
 @command(
     b'blackbox',
     [
         (b'l', b'limit', 10, _(b'the number of events to show')),
     ],
     _(b'hg blackbox [OPTION]...'),
     helpcategory=command.CATEGORY_MAINTENANCE,
     helpbasic=True,
 )
 def blackbox(ui, repo, *revs, **opts):
     """view the recent repository events"""
 
     if not repo.vfs.exists(b'blackbox.log'):
         return
 
     limit = opts.get('limit')
     assert limit is not None  # help pytype
 
     fp = repo.vfs(b'blackbox.log', b'r')
     lines = fp.read().split(b'\n')
 
     count = 0
     output = []
     for line in reversed(lines):
         if count >= limit:
             break
 
         # count the commands by matching lines like:
         # 2013/01/23 19:13:36 root>
         # 2013/01/23 19:13:36 root (1234)>
         # 2013/01/23 19:13:36 root @0000000000000000000000000000000000000000 (1234)>
         # 2013-01-23 19:13:36.000 root @0000000000000000000000000000000000000000 (1234)>
         if re.match(
             br'^\d{4}[-/]\d{2}[-/]\d{2} \d{2}:\d{2}:\d{2}(.\d*)? .*> .*', line
         ):
             count += 1
         output.append(line)
 
     ui.status(b'\n'.join(reversed(output)))

mercurial/bundle2.py

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

mercurial/configitems.toml

@@ -1,2839 +1,2845 b''
 # configitems.toml - centralized declaration of configuration options
 #
 # This file contains declarations of the core Mercurial configuration options.
 #
 # # Structure
 #
 # items: array of config items
 # templates: mapping of template name to template declaration
 # template-applications: array of template applications
 #
 # # Elements
 #
 # ## Item
 #
 # Declares a core Mercurial option.
 #
 # - section: string (required)
 # - name: string (required)
 # - default-type: boolean, changes how `default` is read
 # - default: any
 # - generic: boolean
 # - priority: integer, only if `generic` is true
 # - alias: list of 2-tuples of strings
 # - experimental: boolean
 # - documentation: string
 # - in_core_extension: string
 #
 # ## Template
 #
 # Declares a group of options to be re-used for multiple sections.
 #
 # - all the same fields as `Item`, except `section` and `name`
 # - `suffix` (string, required)
 #
 # ## Template applications
 #
 # Uses a `Template` to instanciate its options in a given section.
 #
 # - template: string (required, must match a `Template` name)
 # - section: string (required)
 
 [[items]]
 section = "alias"
 name = ".*"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "auth"
 name = "cookiefile"
 
 # bookmarks.pushing: internal hack for discovery
 [[items]]
 section = "bookmarks"
 name = "pushing"
 default-type = "list_type"
 
 # bundle.mainreporoot: internal hack for bundlerepo
 [[items]]
 section = "bundle"
 name = "mainreporoot"
 default = ""
 
 [[items]]
 section = "censor"
 name = "policy"
 default = "abort"
 experimental = true
 
 [[items]]
 section = "chgserver"
 name = "idletimeout"
 default = 3600
 
 [[items]]
 section = "chgserver"
 name = "skiphash"
 default = false
 
 [[items]]
 section = "cmdserver"
 name = "log"
 
 [[items]]
 section = "cmdserver"
 name = "max-log-files"
 default = 7
 
 [[items]]
 section = "cmdserver"
 name = "max-log-size"
 default = "1 MB"
 
 [[items]]
 section = "cmdserver"
 name = "max-repo-cache"
 default = 0
 experimental = true
 
 [[items]]
 section = "cmdserver"
 name = "message-encodings"
 default-type = "list_type"
 
 [[items]]
 section = "cmdserver"
 name = "shutdown-on-interrupt"
 default = true
 
 [[items]]
 section = "cmdserver"
 name = "track-log"
 default-type = "lambda"
 default = [ "chgserver", "cmdserver", "repocache",]
 
 [[items]]
 section = "color"
 name = ".*"
 generic = true
 
 [[items]]
 section = "color"
 name = "mode"
 default = "auto"
 
 [[items]]
 section = "color"
 name = "pagermode"
 default-type = "dynamic"
 
 [[items]]
 section = "command-templates"
 name = "graphnode"
 alias = [["ui", "graphnodetemplate"]]
 
 [[items]]
 section = "command-templates"
 name = "log"
 alias = [["ui", "logtemplate"]]
 
 [[items]]
 section = "command-templates"
 name = "mergemarker"
 default = '{node|short} {ifeq(tags, "tip", "", ifeq(tags, "", "", "{tags} "))}{if(bookmarks, "{bookmarks} ")}{ifeq(branch, "default", "", "{branch} ")}- {author|user}: {desc|firstline}'
 alias = [["ui", "mergemarkertemplate"]]
 
 [[items]]
 section = "command-templates"
 name = "oneline-summary"
 
 [[items]]
 section = "command-templates"
 name = "oneline-summary.*"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "command-templates"
 name = "pre-merge-tool-output"
 alias = [["ui", "pre-merge-tool-output-template"]]
 
 [[items]]
 section = "commands"
 name = "commit.post-status"
 default = false
 
 [[items]]
 section = "commands"
 name = "grep.all-files"
 default = false
 experimental = true
 
 [[items]]
 section = "commands"
 name = "merge.require-rev"
 default = false
 
 [[items]]
 section = "commands"
 name = "push.require-revs"
 default = false
 
 # Rebase related configuration moved to core because other extension are doing
 # strange things. For example, shelve import the extensions to reuse some bit
 # without formally loading it.
 [[items]]
 section = "commands"
 name = "rebase.requiredest"
 default = false
 
 [[items]]
 section = "commands"
 name = "resolve.confirm"
 default = false
 
 [[items]]
 section = "commands"
 name = "resolve.explicit-re-merge"
 default = false
 
 [[items]]
 section = "commands"
 name = "resolve.mark-check"
 default = "none"
 
 [[items]]
 section = "commands"
 name = "show.aliasprefix"
 default-type = "list_type"
 
 [[items]]
 section = "commands"
 name = "status.relative"
 default = false
 
 [[items]]
 section = "commands"
 name = "status.skipstates"
 default = []
 experimental = true
 
 [[items]]
 section = "commands"
 name = "status.terse"
 default = ""
 
 [[items]]
 section = "commands"
 name = "status.verbose"
 default = false
 
 [[items]]
 section = "commands"
 name = "update.check"
 
 [[items]]
 section = "commands"
 name = "update.requiredest"
 default = false
 
 [[items]]
 section = "committemplate"
 name = ".*"
 generic = true
 
 [[items]]
 section = "convert"
 name = "bzr.saverev"
 default = true
 
 [[items]]
 section = "convert"
 name = "cvsps.cache"
 default = true
 
 [[items]]
 section = "convert"
 name = "cvsps.fuzz"
 default = 60
 
 [[items]]
 section = "convert"
 name = "cvsps.logencoding"
 
 [[items]]
 section = "convert"
 name = "cvsps.mergefrom"
 
 [[items]]
 section = "convert"
 name = "cvsps.mergeto"
 
 [[items]]
 section = "convert"
 name = "git.committeractions"
 default-type = "lambda"
 default = [ "messagedifferent",]
 
 [[items]]
 section = "convert"
 name = "git.extrakeys"
 default-type = "list_type"
 
 [[items]]
 section = "convert"
 name = "git.findcopiesharder"
 default = false
 
 [[items]]
 section = "convert"
 name = "git.remoteprefix"
 default = "remote"
 
 [[items]]
 section = "convert"
 name = "git.renamelimit"
 default = 400
 
 [[items]]
 section = "convert"
 name = "git.saverev"
 default = true
 
 [[items]]
 section = "convert"
 name = "git.similarity"
 default = 50
 
 [[items]]
 section = "convert"
 name = "git.skipsubmodules"
 default = false
 
 [[items]]
 section = "convert"
 name = "hg.clonebranches"
 default = false
 
 [[items]]
 section = "convert"
 name = "hg.ignoreerrors"
 default = false
 
 [[items]]
 section = "convert"
 name = "hg.preserve-hash"
 default = false
 
 [[items]]
 section = "convert"
 name = "hg.revs"
 
 [[items]]
 section = "convert"
 name = "hg.saverev"
 default = false
 
 [[items]]
 section = "convert"
 name = "hg.sourcename"
 
 [[items]]
 section = "convert"
 name = "hg.startrev"
 
 [[items]]
 section = "convert"
 name = "hg.tagsbranch"
 default = "default"
 
 [[items]]
 section = "convert"
 name = "hg.usebranchnames"
 default = true
 
 [[items]]
 section = "convert"
 name = "ignoreancestorcheck"
 default = false
 experimental = true
 
 [[items]]
 section = "convert"
 name = "localtimezone"
 default = false
 
 [[items]]
 section = "convert"
 name = "p4.encoding"
 default-type = "dynamic"
 
 [[items]]
 section = "convert"
 name = "p4.startrev"
 default = 0
 
 [[items]]
 section = "convert"
 name = "skiptags"
 default = false
 
 [[items]]
 section = "convert"
 name = "svn.branches"
 
 [[items]]
 section = "convert"
 name = "svn.dangerous-set-commit-dates"
 default = false
 
 [[items]]
 section = "convert"
 name = "svn.debugsvnlog"
 default = true
 
 [[items]]
 section = "convert"
 name = "svn.startrev"
 default = 0
 
 [[items]]
 section = "convert"
 name = "svn.tags"
 
 [[items]]
 section = "convert"
 name = "svn.trunk"
 
 [[items]]
 section = "debug"
 name = "bundling-stats"
 default = false
 documentation = "Display extra information about the bundling process."
 
 [[items]]
 section = "debug"
 name = "dirstate.delaywrite"
 default = 0
 
 [[items]]
 section = "debug"
 name = "revlog.debug-delta"
 default = false
 
 [[items]]
 section = "debug"
 name = "revlog.verifyposition.changelog"
 default = ""
 
 [[items]]
 section = "debug"
 name = "unbundling-stats"
 default = false
 documentation = "Display extra information about the unbundling process."
 
 [[items]]
 section = "defaults"
 name = ".*"
 generic = true
 
 [[items]]
 section = "devel"
 name = "all-warnings"
 default = false
 
 [[items]]
 section = "devel"
 name = "bundle.delta"
 default = ""
 
 [[items]]
 section = "devel"
 name = "bundle2.debug"
 default = false
 
 [[items]]
 section = "devel"
 name = "cache-vfs"
 
 [[items]]
 section = "devel"
 name = "check-locks"
 default = false
 
 [[items]]
 section = "devel"
 name = "check-relroot"
 default = false
 
 [[items]]
 section = "devel"
 name = "copy-tracing.multi-thread"
 default = true
 
 # Track copy information for all files, not just "added" ones (very slow)
 [[items]]
 section = "devel"
 name = "copy-tracing.trace-all-files"
 default = false
 
 [[items]]
 section = "devel"
 name = "debug.abort-update"
 default = false
 documentation = """If true, then any merge with the working copy, \
 e.g. [hg update], will be aborted after figuring out what needs to be done, \
 but before spawning the parallel worker."""
 
 [[items]]
 section = "devel"
 name = "debug.copies"
 default = false
 
 [[items]]
 section = "devel"
 name = "debug.extensions"
 default = false
 
 [[items]]
 section = "devel"
 name = "debug.peer-request"
 default = false
 
 [[items]]
 section = "devel"
 name = "debug.repo-filters"
 default = false
 
 [[items]]
 section = "devel"
 name = "default-date"
 
 [[items]]
 section = "devel"
 name = "deprec-warn"
 default = false
 
 # possible values:
 # - auto (the default)
 # - force-append
 # - force-new
 [[items]]
 section = "devel"
 name = "dirstate.v2.data_update_mode"
 default = "auto"
 
 [[items]]
 section = "devel"
 name = "disableloaddefaultcerts"
 default = false
 
 [[items]]
 section = "devel"
 name = "discovery.exchange-heads"
 default = true
 documentation = """If false, the discovery will not start with remote \
 head fetching and local head querying."""
 
 [[items]]
 section = "devel"
 name = "discovery.grow-sample"
 default = true
 documentation = """If false, the sample size used in set discovery \
 will not be increased through the process."""
 
 [[items]]
 section = "devel"
 name = "discovery.grow-sample.dynamic"
 default = true
 documentation = """If true, the default, the sample size is adapted to the shape \
 of the undecided set. It is set to the max of:
 `<target-size>, len(roots(undecided)), len(heads(undecided))`"""
 
 [[items]]
 section = "devel"
 name = "discovery.grow-sample.rate"
 default = 1.05
 documentation = "Controls the rate at which the sample grows."
 
 [[items]]
 section = "devel"
 name = "discovery.randomize"
 default = true
 documentation = """If false, random samplings during discovery are deterministic. \
 It is meant for integration tests."""
 
 [[items]]
 section = "devel"
 name = "discovery.sample-size"
 default = 200
 documentation = "Controls the initial size of the discovery sample."
 
 [[items]]
 section = "devel"
 name = "discovery.sample-size.initial"
 default = 100
 documentation = "Controls the initial size of the discovery for initial change."
 
 [[items]]
 section = "devel"
 name = "legacy.exchange"
 default-type = "list_type"
 
 [[items]]
 section = "devel"
 name = "persistent-nodemap"
 default = false
 documentation = """When true, revlogs use a special reference version of the \
 nodemap, that is not performant but is "known" to behave properly."""
 
 [[items]]
 section = "devel"
 name = "server-insecure-exact-protocol"
 default = ""
 
 [[items]]
 section = "devel"
 name = "servercafile"
 default = ""
 
 [[items]]
 section = "devel"
 name = "serverexactprotocol"
 default = ""
 
 [[items]]
 section = "devel"
 name = "serverrequirecert"
 default = false
 
 [[items]]
 section = "devel"
 name = "strip-obsmarkers"
 default = true
 
 [[items]]
 section = 'devel'
 name = 'sync.status.pre-dirstate-write-file'
 documentation = """
 Makes the status algorithm wait for the existence of this file \
 (or until a timeout of `devel.sync.status.pre-dirstate-write-file-timeout` \
 seconds) before taking the lock and writing the dirstate. \
 Status signals that it's ready to wait by creating a file \
 with the same name + `.waiting`. \
 Useful when testing race conditions."""
 
 [[items]]
 section = 'devel'
 name = 'sync.status.pre-dirstate-write-file-timeout'
 default=2
 
 [[items]]
 section = 'devel'
 name = 'sync.dirstate.post-docket-read-file'
 
 [[items]]
 section = 'devel'
 name = 'sync.dirstate.post-docket-read-file-timeout'
 default=2
 
 [[items]]
 section = 'devel'
 name = 'sync.dirstate.pre-read-file'
 
 [[items]]
 section = 'devel'
 name = 'sync.dirstate.pre-read-file-timeout'
 default=2
 
 [[items]]
 section = "devel"
 name = "user.obsmarker"
 
 [[items]]
 section = "devel"
 name = "warn-config"
 
 [[items]]
 section = "devel"
 name = "warn-config-default"
 
 [[items]]
 section = "devel"
 name = "warn-config-unknown"
 
 [[items]]
 section = "devel"
 name = "warn-empty-changegroup"
 default = false
 
 [[items]]
 section = "diff"
 name = "merge"
 default = false
 experimental = true
 
 [[items]]
 section = "email"
 name = "bcc"
 
 [[items]]
 section = "email"
 name = "cc"
 
 [[items]]
 section = "email"
 name = "charsets"
 default-type = "list_type"
 
 [[items]]
 section = "email"
 name = "from"
 
 [[items]]
 section = "email"
 name = "method"
 default = "smtp"
 
 [[items]]
 section = "email"
 name = "reply-to"
 
 [[items]]
 section = "email"
 name = "to"
 
 [[items]]
 section = "experimental"
 name = "archivemetatemplate"
 default-type = "dynamic"
 
 [[items]]
 section = "experimental"
 name = "auto-publish"
 default = "publish"
 
 [[items]]
 section = "experimental"
 name = "bundle-phases"
 default = false
 
 [[items]]
 section = "experimental"
 name = "bundle2-advertise"
 default = true
 
 [[items]]
 section = "experimental"
 name = "bundle2-output-capture"
 default = false
 
 [[items]]
 section = "experimental"
 name = "bundle2.pushback"
 default = false
 
 [[items]]
 section = "experimental"
 name = "bundle2lazylocking"
 default = false
 
 [[items]]
 section = "experimental"
 name = "bundlecomplevel"
 
 [[items]]
 section = "experimental"
 name = "bundlecomplevel.bzip2"
 
 [[items]]
 section = "experimental"
 name = "bundlecomplevel.gzip"
 
 [[items]]
 section = "experimental"
 name = "bundlecomplevel.none"
 
 [[items]]
 section = "experimental"
 name = "bundlecomplevel.zstd"
 
 [[items]]
 section = "experimental"
 name = "bundlecompthreads"
 
 [[items]]
 section = "experimental"
 name = "bundlecompthreads.bzip2"
 
 [[items]]
 section = "experimental"
 name = "bundlecompthreads.gzip"
 
 [[items]]
 section = "experimental"
 name = "bundlecompthreads.none"
 
 [[items]]
 section = "experimental"
 name = "bundlecompthreads.zstd"
 
 [[items]]
 section = "experimental"
 name = "changegroup3"
 default = true
 
 [[items]]
 section = "experimental"
 name = "changegroup4"
 default = false
 
 # might remove rank configuration once the computation has no impact
 [[items]]
 section = "experimental"
 name = "changelog-v2.compute-rank"
 default = true
 
 [[items]]
 section = "experimental"
 name = "cleanup-as-archived"
 default = false
 
 [[items]]
 section = "experimental"
 name = "clientcompressionengines"
 default-type = "list_type"
 
 [[items]]
 section = "experimental"
 name = "copies.read-from"
 default = "filelog-only"
 
 [[items]]
 section = "experimental"
 name = "copies.write-to"
 default = "filelog-only"
 
 [[items]]
 section = "experimental"
 name = "copytrace"
 default = "on"
 
 [[items]]
 section = "experimental"
 name = "copytrace.movecandidateslimit"
 default = 100
 
 [[items]]
 section = "experimental"
 name = "copytrace.sourcecommitlimit"
 default = 100
 
 [[items]]
 section = "experimental"
 name = "crecordtest"
 
 [[items]]
 section = "experimental"
 name = "directaccess"
 default = false
 
 [[items]]
 section = "experimental"
 name = "directaccess.revnums"
 default = false
 
 [[items]]
 section = "experimental"
 name = "editortmpinhg"
 default = false
 
 [[items]]
 section = "experimental"
 name = "evolution"
 default-type = "list_type"
 
 [[items]]
 section = "experimental"
 name = "evolution.allowdivergence"
 default = false
 alias = [["experimental", "allowdivergence"]]
 
 [[items]]
 section = "experimental"
 name = "evolution.allowunstable"
 
 [[items]]
 section = "experimental"
 name = "evolution.bundle-obsmarker"
 default = false
 
 [[items]]
 section = "experimental"
 name = "evolution.bundle-obsmarker:mandatory"
 default = true
 
 [[items]]
 section = "experimental"
 name = "evolution.createmarkers"
 
 [[items]]
 section = "experimental"
 name = "evolution.effect-flags"
 default = true
 alias = [["experimental", "effect-flags"]]
 
 [[items]]
 section = "experimental"
 name = "evolution.exchange"
 
 [[items]]
 section = "experimental"
 name = "evolution.report-instabilities"
 default = true
 
 [[items]]
 section = "experimental"
 name = "evolution.track-operation"
 default = true
 
 [[items]]
 section = "experimental"
 name = "exportableenviron"
 default-type = "list_type"
 
 [[items]]
 section = "experimental"
 name = "extendedheader.index"
 
 [[items]]
 section = "experimental"
 name = "extendedheader.similarity"
 default = false
 
 [[items]]
 section = "experimental"
 name = "extra-filter-revs"
 documentation = """Repo-level config to prevent a revset from being visible.
 The target use case is to use `share` to expose different subsets of the same \
 repository, especially server side. See also `server.view`."""
 
 [[items]]
 section = "experimental"
 name = "graphshorten"
 default = false
 
 [[items]]
 section = "experimental"
 name = "graphstyle.grandparent"
 default-type = "dynamic"
 
 [[items]]
 section = "experimental"
 name = "graphstyle.missing"
 default-type = "dynamic"
 
 [[items]]
 section = "experimental"
 name = "graphstyle.parent"
 default-type = "dynamic"
 
 [[items]]
 section = "experimental"
 name = "hook-track-tags"
 default = false
 
 [[items]]
 section = "experimental"
 name = "httppostargs"
 default = false
 
 [[items]]
 section = "experimental"
 name = "log.topo"
 default = false
 
 [[items]]
 section = "experimental"
 name = "maxdeltachainspan"
 default = -1
 
 [[items]]
 section = "experimental"
 name = "merge-track-salvaged"
 default = false
 documentation = """Tracks files which were undeleted (merge might delete them \
 but we explicitly kept/undeleted them) and creates new filenodes for them."""
 
 [[items]]
 section = "experimental"
 name = "merge.checkpathconflicts"
 default = false
 
 [[items]]
 section = "experimental"
 name = "mmapindexthreshold"
 
 [[items]]
 section = "experimental"
 name = "narrow"
 default = false
 
 [[items]]
 section = "experimental"
 name = "nointerrupt"
 default = false
 
 [[items]]
 section = "experimental"
 name = "nointerrupt-interactiveonly"
 default = true
 
 [[items]]
 section = "experimental"
 name = "nonnormalparanoidcheck"
 default = false
 
 [[items]]
 section = "experimental"
 name = "obsmarkers-exchange-debug"
 default = false
 
 [[items]]
 section = "experimental"
 name = "rebaseskipobsolete"
 default = true
 
 [[items]]
 section = "experimental"
 name = "remotenames"
 default = false
 
 [[items]]
 section = "experimental"
 name = "removeemptydirs"
 default = true
 
 [[items]]
 section = "experimental"
 name = "revert.interactive.select-to-keep"
 default = false
 
 [[items]]
 section = "experimental"
 name = "revisions.disambiguatewithin"
 
 [[items]]
 section = "experimental"
 name = "revisions.prefixhexnode"
 default = false
 
 # "out of experimental" todo list.
 #
 # * include management of a persistent nodemap in the main docket
 # * enforce a "no-truncate" policy for mmap safety
 #      - for censoring operation
 #      - for stripping operation
 #      - for rollback operation
 # * proper streaming (race free) of the docket file
 # * track garbage data to evemtually allow rewriting -existing- sidedata.
 # * Exchange-wise, we will also need to do something more efficient than
 #   keeping references to the affected revlogs, especially memory-wise when
 #   rewriting sidedata.
 # * introduce a proper solution to reduce the number of filelog related files.
 # * use caching for reading sidedata (similar to what we do for data).
 # * no longer set offset=0 if sidedata_size=0 (simplify cutoff computation).
 # * Improvement to consider
 #   - avoid compression header in chunk using the default compression?
 #   - forbid "inline" compression mode entirely?
 #   - split the data offset and flag field (the 2 bytes save are mostly trouble)
 #   - keep track of uncompressed -chunk- size (to preallocate memory better)
 #   - keep track of chain base or size (probably not that useful anymore)
 [[items]]
 section = "experimental"
 name = "revlogv2"
 
 [[items]]
 section = "experimental"
 name = "rust.index"
 default = false
 
 [[items]]
 section = "experimental"
 name = "server.allow-hidden-access"
 default-type = "list_type"
 
 [[items]]
 section = "experimental"
 name = "server.filesdata.recommended-batch-size"
 default = 50000
 
 [[items]]
 section = "experimental"
 name = "server.manifestdata.recommended-batch-size"
 default = 100000
 
 [[items]]
 section = "experimental"
 name = "server.stream-narrow-clones"
 default = false
 
 [[items]]
 section = "experimental"
 name = "single-head-per-branch"
 default = false
 
 [[items]]
 section = "experimental"
 name = "single-head-per-branch:account-closed-heads"
 default = false
 
 [[items]]
 section = "experimental"
 name = "single-head-per-branch:public-changes-only"
 default = false
 
 [[items]]
 section = "experimental"
 name = "sparse-read"
 default = false
 
 [[items]]
 section = "experimental"
 name = "sparse-read.density-threshold"
 default = 0.5
 
 [[items]]
 section = "experimental"
 name = "sparse-read.min-gap-size"
 default = "65K"
 
 [[items]]
 section = "experimental"
 name = "stream-v3"
 default = false
 
 [[items]]
 section = "experimental"
 name = "treemanifest"
 default = false
 
 [[items]]
 section = "experimental"
 name = "update.atomic-file"
 default = false
 
 [[items]]
 section = "experimental"
 name = "web.full-garbage-collection-rate"
 default = 1  # still forcing a full collection on each request
 
 [[items]]
 section = "experimental"
 name = "worker.repository-upgrade"
 default = false
 
 [[items]]
 section = "experimental"
 name = "worker.wdir-get-thread-safe"
 default = false
 
 [[items]]
 section = "experimental"
 name = "xdiff"
 default = false
 
 [[items]]
 section = "extdata"
 name = ".*"
 generic = true
 
 [[items]]
 section = "extensions"
 name = "[^:]*"
 generic = true
 
 [[items]]
 section = "extensions"
 name = "[^:]*:required"
 default = false
 generic = true
 
 [[items]]
 section = "format"
 name = "bookmarks-in-store"
 default = false
 
 [[items]]
 section = "format"
 name = "chunkcachesize"
 experimental = true
 
 [[items]]
 section = "format"
 name = "dotencode"
 default = true
 
 # The interaction between the archived phase and obsolescence markers needs to
 # be sorted out before wider usage of this are to be considered.
 #
 # At the time this message is written, behavior when archiving obsolete
 # changeset differ significantly from stripping. As part of stripping, we also
 # remove the obsolescence marker associated to the stripped changesets,
 # revealing the precedecessors changesets when applicable. When archiving, we
 # don't touch the obsolescence markers, keeping everything hidden. This can
 # result in quite confusing situation for people combining exchanging draft
 # with the archived phases. As some markers needed by others may be skipped
 # during exchange.
 [[items]]
 section = "format"
 name = "exp-archived-phase"
 default = false
 experimental = true
 
 # Experimental TODOs:
 #
 # * Same as for revlogv2 (but for the reduction of the number of files)
 # * Actually computing the rank of changesets
 # * Improvement to investigate
 #   - storing .hgtags fnode
 #   - storing branch related identifier
 [[items]]
 section = "format"
 name = "exp-use-changelog-v2"
 experimental = true
 
 [[items]]
 section = "format"
 name = "exp-use-copies-side-data-changeset"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "generaldelta"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "manifestcachesize"
 experimental = true
 
 [[items]]
 section = "format"
 name = "maxchainlen"
 default-type = "dynamic"
 experimental = true
 
 [[items]]
 section = "format"
 name = "obsstore-version"
 
 [[items]]
 section = "format"
 name = "revlog-compression"
 default-type = "lambda"
 alias = [["experimental", "format.compression"]]
 default = [ "zstd", "zlib",]
 
 [[items]]
 section = "format"
 name = "sparse-revlog"
 default = true
 
 [[items]]
 section = "format"
 name = "use-dirstate-tracked-hint"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-dirstate-tracked-hint.automatic-upgrade-of-mismatching-repositories"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-dirstate-tracked-hint.automatic-upgrade-of-mismatching-repositories:quiet"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-dirstate-tracked-hint.version"
 default = 1
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-dirstate-v2"
 default = false
 alias = [["format", "exp-rc-dirstate-v2"]]
 experimental = true
 documentation = """Enables dirstate-v2 format *when creating a new repository*.
 Which format to use for existing repos is controlled by `.hg/requires`."""
 
 [[items]]
 section = "format"
 name = "use-dirstate-v2.automatic-upgrade-of-mismatching-repositories"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-dirstate-v2.automatic-upgrade-of-mismatching-repositories:quiet"
 default = false
 experimental = true
 
 # Having this on by default means we are confident about the scaling of phases.
 # This is not garanteed to be the case at the time this message is written.
 [[items]]
 section = "format"
 name = "use-internal-phase"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-persistent-nodemap"
 default-type = "dynamic"
 
 [[items]]
 section = "format"
 name = "use-share-safe"
 default = true
 
 [[items]]
 section = "format"
 name = "use-share-safe.automatic-upgrade-of-mismatching-repositories"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-share-safe.automatic-upgrade-of-mismatching-repositories:quiet"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "usefncache"
 default = true
 
 [[items]]
 section = "format"
 name = "usegeneraldelta"
 default = true
 
 [[items]]
 section = "format"
 name = "usestore"
 default = true
 
 [[items]]
 section = "fsmonitor"
 name = "warn_update_file_count"
 default = 50000
 
 [[items]]
 section = "fsmonitor"
 name = "warn_update_file_count_rust"
 default = 400000
 
 [[items]]
 section = "fsmonitor"
 name = "warn_when_unused"
 default = true
 
 [[items]]
 section = "help"
 name = 'hidden-command\..*'
 default = false
 generic = true
 
 [[items]]
 section = "help"
 name = 'hidden-topic\..*'
 default = false
 generic = true
 
 [[items]]
 section = "hgweb-paths"
 name = ".*"
 default-type = "list_type"
 generic = true
 
 [[items]]
 section = "hooks"
 name = ".*:run-with-plain"
 default = true
 generic = true
 
 [[items]]
 section = "hooks"
 name = "[^:]*"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "hostfingerprints"
 name = ".*"
 default-type = "list_type"
 generic = true
 
 [[items]]
 section = "hostsecurity"
 name = ".*:ciphers$"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "hostsecurity"
 name = ".*:fingerprints$"
 default-type = "list_type"
 generic = true
 
 [[items]]
 section = "hostsecurity"
 name = ".*:minimumprotocol$"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "hostsecurity"
 name = ".*:verifycertsfile$"
 generic = true
 
 [[items]]
 section = "hostsecurity"
 name = "ciphers"
 
 [[items]]
 section = "hostsecurity"
 name = "minimumprotocol"
 default-type = "dynamic"
 
 [[items]]
 section = "http"
 name = "timeout"
 
 [[items]]
 section = "http_proxy"
 name = "always"
 default = false
 
 [[items]]
 section = "http_proxy"
 name = "host"
 
 [[items]]
 section = "http_proxy"
 name = "no"
 default-type = "list_type"
 
 [[items]]
 section = "http_proxy"
 name = "passwd"
 
 [[items]]
 section = "http_proxy"
 name = "user"
 
 [[items]]
 section = "logtoprocess"
 name = "command"
 
 [[items]]
 section = "logtoprocess"
 name = "commandexception"
 
 [[items]]
 section = "logtoprocess"
 name = "commandfinish"
 
 [[items]]
 section = "logtoprocess"
 name = "develwarn"
 
 [[items]]
 section = "logtoprocess"
 name = "uiblocked"
 
 [[items]]
 section = "merge"
 name = "checkignored"
 default = "abort"
 
 [[items]]
 section = "merge"
 name = "checkunknown"
 default = "abort"
 
 [[items]]
 section = "merge"
 name = "disable-partial-tools"
 default = false
 experimental = true
 
 [[items]]
 section = "merge"
 name = "followcopies"
 default = true
 
 [[items]]
 section = "merge"
 name = "on-failure"
 default = "continue"
 
 [[items]]
 section = "merge"
 name = "preferancestor"
 default-type = "lambda"
 default = ["*"]
 experimental = true
 
 [[items]]
 section = "merge"
 name = "strict-capability-check"
 default = false
 
 [[items]]
 section = "merge-tools"
 name = ".*"
 generic = true
 
 [[items]]
 section = "merge-tools"
 name = '.*\.args$'
 default = "$local $base $other"
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.binary$'
 default = false
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.check$'
 default-type = "list_type"
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.checkchanged$'
 default = false
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.executable$'
 default-type = "dynamic"
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.fixeol$'
 default = false
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.gui$'
 default = false
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.mergemarkers$'
 default = "basic"
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.mergemarkertemplate$'  # take from command-templates.mergemarker
 default-type = "dynamic"
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.premerge$'
 default-type = "dynamic"
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.priority$'
 default = 0
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.regappend$'
 default = ""
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.symlink$'
 default = false
 generic = true
 priority = -1
 
 [[items]]
 section = "pager"
 name = "attend-.*"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "pager"
 name = "ignore"
 default-type = "list_type"
 
 [[items]]
 section = "pager"
 name = "pager"
 default-type = "dynamic"
 
 [[items]]
 section = "partial-merge-tools"
 name = ".*"
 generic = true
 experimental = true
 
 [[items]]
 section = "partial-merge-tools"
 name = '.*\.args'
 default = "$local $base $other"
 generic = true
 priority = -1
 experimental = true
 
 [[items]]
 section = "partial-merge-tools"
 name = '.*\.disable'
 default = false
 generic = true
 priority = -1
 experimental = true
 
 [[items]]
 section = "partial-merge-tools"
 name = '.*\.executable$'
 default-type = "dynamic"
 generic = true
 priority = -1
 experimental = true
 
 [[items]]
 section = "partial-merge-tools"
 name = '.*\.order'
 default = 0
 generic = true
 priority = -1
 experimental = true
 
 [[items]]
 section = "partial-merge-tools"
 name = '.*\.patterns'
 default-type = "dynamic"
 generic = true
 priority = -1
 experimental = true
 
 [[items]]
 section = "patch"
 name = "eol"
 default = "strict"
 
 [[items]]
 section = "patch"
 name = "fuzz"
 default = 2
 
 [[items]]
 section = "paths"
 name = "[^:]*"
 generic = true
 
 [[items]]
 section = "paths"
 name = ".*:bookmarks.mode"
 default = "default"
 generic = true
 
 [[items]]
 section = "paths"
 name = ".*:multi-urls"
 default = false
 generic = true
 
 [[items]]
 section = "paths"
 name = ".*:pulled-delta-reuse-policy"
 generic = true
 
 [[items]]
 section = "paths"
 name = ".*:pushrev"
 generic = true
 
 [[items]]
 section = "paths"
 name = ".*:pushurl"
 generic = true
 
 [[items]]
 section = "paths"
 name = "default"
 
 [[items]]
 section = "paths"
 name = "default-push"
 
 [[items]]
 section = "phases"
 name = "checksubrepos"
 default = "follow"
 
 [[items]]
 section = "phases"
 name = "new-commit"
 default = "draft"
 
 [[items]]
 section = "phases"
 name = "publish"
 default = true
 
 [[items]]
 section = "profiling"
 name = "enabled"
 default = false
 
 [[items]]
 section = "profiling"
 name = "format"
 default = "text"
 
 [[items]]
 section = "profiling"
 name = "freq"
 default = 1000
 
 [[items]]
 section = "profiling"
 name = "limit"
 default = 30
 
 [[items]]
 section = "profiling"
 name = "nested"
 default = 0
 
 [[items]]
 section = "profiling"
 name = "output"
 
 [[items]]
 section = "profiling"
 name = "showmax"
 default = 0.999
 
 [[items]]
 section = "profiling"
 name = "showmin"
 default-type = "dynamic"
 
 [[items]]
 section = "profiling"
 name = "showtime"
 default = true
 
 [[items]]
 section = "profiling"
 name = "sort"
 default = "inlinetime"
 
 [[items]]
 section = "profiling"
 name = "statformat"
 default = "hotpath"
 
 [[items]]
 section = "profiling"
 name = "time-track"
 default-type = "dynamic"
 
 [[items]]
 section = "profiling"
 name = "type"
 default = "stat"
 
 [[items]]
 section = "progress"
 name = "assume-tty"
 default = false
 
 [[items]]
 section = "progress"
 name = "changedelay"
 default = 1
 
 [[items]]
 section = "progress"
 name = "clear-complete"
 default = true
 
 [[items]]
 section = "progress"
 name = "debug"
 default = false
 
 [[items]]
 section = "progress"
 name = "delay"
 default = 3
 
 [[items]]
 section = "progress"
 name = "disable"
 default = false
 
 [[items]]
 section = "progress"
 name = "estimateinterval"
 default = 60.0
 
 [[items]]
 section = "progress"
 name = "format"
 default-type = "lambda"
 default = [ "topic", "bar", "number", "estimate",]
 
 [[items]]
 section = "progress"
 name = "refresh"
 default = 0.1
 
 [[items]]
 section = "progress"
 name = "width"
 default-type = "dynamic"
 
 [[items]]
 section = "pull"
 name = "confirm"
 default = false
 
 [[items]]
 section = "push"
 name = "pushvars.server"
 default = false
 
 [[items]]
 section = "rebase"
 name = "experimental.inmemory"
 default = false
 
 [[items]]
 section = "rebase"
 name = "singletransaction"
 default = false
 
 [[items]]
 section = "rebase"
 name = "store-source"
 default = true
 experimental = true
 documentation = """Controls creation of a `rebase_source` extra field during rebase.
 When false, no such field is created. This is useful e.g. for incrementally \
 converting changesets and then rebasing them onto an existing repo.
 WARNING: this is an advanced setting reserved for people who know \
 exactly what they are doing. Misuse of this setting can easily \
 result in obsmarker cycles and a vivid headache."""
 
 [[items]]
 section = "rewrite"
 name = "backup-bundle"
 default = true
 alias = [["ui", "history-editing-backup"]]
 
 [[items]]
 section = "rewrite"
 name = "empty-successor"
 default = "skip"
 experimental = true
 
 [[items]]
 section = "rewrite"
 name = "update-timestamp"
 default = false
 
 [[items]]
 section = "rhg"
 name = "cat"
 default = true
 experimental = true
 documentation = """rhg cat has some quirks that need to be ironed out. \
 In particular, the `-r` argument accepts a partial hash, but does not \
 correctly resolve `abcdef` as a potential bookmark, tag or branch name."""
 
 [[items]]
 section = "rhg"
 name = "fallback-exectutable"
 experimental = true
 
 [[items]]
 section = "rhg"
 name = "fallback-immediately"
 default = false
 experimental = true
 
 [[items]]
 section = "rhg"
 name = "ignored-extensions"
 default-type = "list_type"
 experimental = true
 
 [[items]]
 section = "rhg"
 name = "on-unsupported"
 default = "abort"
 experimental = true
 
 [[items]]
 section = "server"
 name = "bookmarks-pushkey-compat"
 default = true
 
 [[items]]
 section = "server"
 name = "bundle1"
 default = true
 
 [[items]]
 section = "server"
 name = "bundle1.pull"
 
 [[items]]
 section = "server"
 name = "bundle1.push"
 
 [[items]]
 section = "server"
 name = "bundle1gd"
 
 [[items]]
 section = "server"
 name = "bundle1gd.pull"
 
 [[items]]
 section = "server"
 name = "bundle1gd.push"
 
 [[items]]
 section = "server"
 name = "bundle2.stream"
 default = true
 alias = [["experimental", "bundle2.stream"]]
 
 [[items]]
 section = "server"
 name = "compressionengines"
 default-type = "list_type"
 
 [[items]]
 section = "server"
 name = "concurrent-push-mode"
 default = "check-related"
 
 [[items]]
 section = "server"
 name = "disablefullbundle"
 default = false
 
 [[items]]
 section = "server"
 name = "maxhttpheaderlen"
 default = 1024
 
 [[items]]
 section = "server"
 name = "preferuncompressed"
 default = false
 
 [[items]]
 section = "server"
 name = "pullbundle"
 default = true
 
 [[items]]
 section = "server"
 name = "streamunbundle"
 default = false
 
 [[items]]
 section = "server"
 name = "uncompressed"
 default = true
 
 [[items]]
 section = "server"
 name = "uncompressedallowsecret"
 default = false
 
 [[items]]
 section = "server"
 name = "validate"
 default = false
 
 [[items]]
 section = "server"
 name = "view"
 default = "served"
 
 [[items]]
 section = "server"
 name = "zliblevel"
 default = -1
 
 [[items]]
 section = "server"
 name = "zstdlevel"
 default = 3
 
 [[items]]
 section = "share"
 name = "pool"
 
 [[items]]
 section = "share"
 name = "poolnaming"
 default = "identity"
 
 [[items]]
 section = "share"
 name = "safe-mismatch.source-not-safe"
 default = "abort"
 
 [[items]]
 section = "share"
 name = "safe-mismatch.source-not-safe.warn"
 default = true
 
 [[items]]
 section = "share"
 name = "safe-mismatch.source-not-safe:verbose-upgrade"
 default = true
 
 [[items]]
 section = "share"
 name = "safe-mismatch.source-safe"
 default = "abort"
 
 [[items]]
 section = "share"
 name = "safe-mismatch.source-safe.warn"
 default = true
 
 [[items]]
 section = "share"
 name = "safe-mismatch.source-safe:verbose-upgrade"
 default = true
 
 [[items]]
 section = "shelve"
 name = "maxbackups"
 default = 10
 
 [[items]]
 section = "shelve"
 name = "store"
 default = "internal"
 experimental = true
 
 [[items]]
 section = "smtp"
 name = "host"
 
 [[items]]
 section = "smtp"
 name = "local_hostname"
 
 [[items]]
 section = "smtp"
 name = "password"
 
 [[items]]
 section = "smtp"
 name = "port"
 default-type = "dynamic"
 
 [[items]]
 section = "smtp"
 name = "tls"
 default = "none"
 
 [[items]]
 section = "smtp"
 name = "username"
 
 [[items]]
 section = "sparse"
 name = "missingwarning"
 default = true
 experimental = true
 
 [[items]]
 section = "storage"
 name = "dirstate-v2.slow-path"
 default = "abort"
 experimental = true  # experimental as long as format.use-dirstate-v2 is.
 
 [[items]]
 section = "storage"
 name = "new-repo-backend"
 default = "revlogv1"
 experimental = true
 
 [[items]]
 section = "storage"
 name = "revlog.delta-parent-search.candidate-group-chunk-size"
 default = 20
 
 [[items]]
 section = "storage"
 name = "revlog.issue6528.fix-incoming"
 default = true
 
 [[items]]
 section = "storage"
 name = "revlog.optimize-delta-parent-choice"
 default = true
 alias = [["format", "aggressivemergedeltas"]]
 
 [[items]]
 section = "storage"
 name = "revlog.persistent-nodemap.mmap"
 default = true
 
 [[items]]
 section = "storage"
 name = "revlog.persistent-nodemap.slow-path"
 default = "abort"
 
 [[items]]
 section = "storage"
 name = "revlog.reuse-external-delta"
 default = true
 
 [[items]]
 section = "storage"
 name = "revlog.reuse-external-delta-parent"
 documentation = """This option is true unless `format.generaldelta` is set."""
 
 [[items]]
 section = "storage"
 name = "revlog.zlib.level"
 
 [[items]]
 section = "storage"
 name = "revlog.zstd.level"
 
 [[items]]
 section = "subrepos"
 name = "allowed"
 default-type = "dynamic"  # to make backporting simpler
 
 [[items]]
 section = "subrepos"
 name = "git:allowed"
 default-type = "dynamic"
 
 [[items]]
 section = "subrepos"
 name = "hg:allowed"
 default-type = "dynamic"
 
 [[items]]
 section = "subrepos"
 name = "svn:allowed"
 default-type = "dynamic"
 
 [[items]]
 section = "templateconfig"
 name = ".*"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "templates"
 name = ".*"
 generic = true
 
 [[items]]
 section = "trusted"
 name = "groups"
 default-type = "list_type"
 
 [[items]]
 section = "trusted"
 name = "users"
 default-type = "list_type"
 
 [[items]]
 section = "ui"
 name = "_usedassubrepo"
 default = false
 
 [[items]]
 section = "ui"
 name = "allowemptycommit"
 default = false
 
 [[items]]
 section = "ui"
 name = "archivemeta"
 default = true
 
 [[items]]
 section = "ui"
 name = "askusername"
 default = false
 
 [[items]]
 section = "ui"
 name = "available-memory"
 
 [[items]]
 section = "ui"
 name = "clonebundlefallback"
 default = false
 
 [[items]]
 section = "ui"
 name = "clonebundleprefers"
 default-type = "list_type"
 
 [[items]]
 section = "ui"
 name = "clonebundles"
 default = true
 
 [[items]]
 section = "ui"
 name = "color"
 default = "auto"
 
 [[items]]
 section = "ui"
 name = "commitsubrepos"
 default = false
 
 [[items]]
 section = "ui"
 name = "debug"
 default = false
 
 [[items]]
 section = "ui"
 name = "debugger"
 
 [[items]]
 section = "ui"
 name = "detailed-exit-code"
 default = false
 experimental = true
 
 [[items]]
 section = "ui"
 name = "editor"
 default-type = "dynamic"
 
 [[items]]
 section = "ui"
 name = "fallbackencoding"
 
 [[items]]
 section = "ui"
 name = "forcecwd"
 
 [[items]]
 section = "ui"
 name = "forcemerge"
 
 [[items]]
 section = "ui"
 name = "formatdebug"
 default = false
 
 [[items]]
 section = "ui"
 name = "formatjson"
 default = false
 
 [[items]]
 section = "ui"
 name = "formatted"
 
 [[items]]
 section = "ui"
 name = "interactive"
 
 [[items]]
 section = "ui"
 name = "interface"
 
 [[items]]
 section = "ui"
 name = "interface.chunkselector"
 
 [[items]]
 section = "ui"
 name = "large-file-limit"
 default = 10485760
 
 [[items]]
 section = "ui"
 name = "logblockedtimes"
 default = false
 
 [[items]]
 section = "ui"
 name = "merge"
 
 [[items]]
 section = "ui"
 name = "mergemarkers"
 default = "basic"
 
 [[items]]
 section = "ui"
 name = "message-output"
 default = "stdio"
 
 [[items]]
 section = "ui"
 name = "nontty"
 default = false
 
 [[items]]
 section = "ui"
 name = "origbackuppath"
 
 [[items]]
 section = "ui"
 name = "paginate"
 default = true
 
 [[items]]
 section = "ui"
 name = "patch"
 
 [[items]]
 section = "ui"
 name = "portablefilenames"
 default = "warn"
 
 [[items]]
 section = "ui"
 name = "promptecho"
 default = false
 
 [[items]]
 section = "ui"
 name = "quiet"
 default = false
 
 [[items]]
 section = "ui"
 name = "quietbookmarkmove"
 default = false
 
 [[items]]
 section = "ui"
 name = "relative-paths"
 default = "legacy"
 
 [[items]]
 section = "ui"
 name = "remotecmd"
 default = "hg"
 
 [[items]]
 section = "ui"
 name = "report_untrusted"
 default = true
 
 [[items]]
 section = "ui"
 name = "rollback"
 default = true
 
 [[items]]
 section = "ui"
 name = "signal-safe-lock"
 default = true
 
 [[items]]
 section = "ui"
 name = "slash"
 default = false
 
 [[items]]
 section = "ui"
 name = "ssh"
 default = "ssh"
 
 [[items]]
 section = "ui"
 name = "ssherrorhint"
 
 [[items]]
 section = "ui"
 name = "statuscopies"
 default = false
 
 [[items]]
 section = "ui"
 name = "strict"
 default = false
 
 [[items]]
 section = "ui"
 name = "style"
 default = ""
 
 [[items]]
 section = "ui"
 name = "supportcontact"
 
 [[items]]
 section = "ui"
 name = "textwidth"
 default = 78
 
 [[items]]
 section = "ui"
 name = "timeout"
 default = "600"
 
 [[items]]
 section = "ui"
 name = "timeout.warn"
 default = 0
 
 [[items]]
 section = "ui"
 name = "timestamp-output"
 default = false
 
 [[items]]
 section = "ui"
 name = "traceback"
 default = false
 
 [[items]]
 section = "ui"
 name = "tweakdefaults"
 default = false
 
 [[items]]
 section = "ui"
 name = "username"
 alias = [["ui", "user"]]
 
 [[items]]
 section = "ui"
 name = "verbose"
 default = false
 
 [[items]]
 section = "verify"
 name = "skipflags"
 default = 0
 
 [[items]]
 section = "web"
 name = "accesslog"
 default = "-"
 
 [[items]]
 section = "web"
 name = "address"
 default = ""
 
 [[items]]
 section = "web"
 name = "allow-archive"
 default-type = "list_type"
 alias = [["web", "allow_archive"]]
 
 [[items]]
 section = "web"
 name = "allow-pull"
 default = true
 alias = [["web", "allowpull"]]
 
 [[items]]
 section = "web"
 name = "allow-push"
 default-type = "list_type"
 alias = [["web", "allow_push"]]
 
 [[items]]
 section = "web"
 name = "allow_read"
 default-type = "list_type"
 
 [[items]]
 section = "web"
 name = "allowbz2"
 default = false
 
 [[items]]
 section = "web"
 name = "allowgz"
 default = false
 
 [[items]]
 section = "web"
 name = "allowzip"
 default = false
 
 [[items]]
 section = "web"
 name = "archivesubrepos"
 default = false
 
 [[items]]
 section = "web"
 name = "baseurl"
 
 [[items]]
 section = "web"
 name = "cacerts"
 
 [[items]]
 section = "web"
 name = "cache"
 default = true
 
 [[items]]
 section = "web"
 name = "certificate"
 
 [[items]]
 section = "web"
 name = "collapse"
 default = false
 
 [[items]]
 section = "web"
 name = "comparisoncontext"
 default = 5
 
 [[items]]
 section = "web"
 name = "contact"
 
 [[items]]
 section = "web"
 name = "csp"
 
 [[items]]
 section = "web"
 name = "deny_push"
 default-type = "list_type"
 
 [[items]]
 section = "web"
 name = "deny_read"
 default-type = "list_type"
 
 [[items]]
 section = "web"
 name = "descend"
 default = true
 
 [[items]]
 section = "web"
 name = "description"
 default = ""
 
 [[items]]
 section = "web"
 name = "encoding"
 default-type = "lazy_module"
 default = "encoding.encoding"
 
 [[items]]
 section = "web"
 name = "errorlog"
 default = "-"
 
 [[items]]
 section = "web"
 name = "guessmime"
 default = false
 
 [[items]]
 section = "web"
 name = "hidden"
 default = false
 
 [[items]]
 section = "web"
 name = "ipv6"
 default = false
 
 [[items]]
 section = "web"
 name = "labels"
 default-type = "list_type"
 
 [[items]]
 section = "web"
 name = "logoimg"
 default = "hglogo.png"
 
 [[items]]
 section = "web"
 name = "logourl"
 default = "https://mercurial-scm.org/"
 
 [[items]]
 section = "web"
 name = "maxchanges"
 default = 10
 
 [[items]]
 section = "web"
 name = "maxfiles"
 default = 10
 
 [[items]]
 section = "web"
 name = "maxshortchanges"
 default = 60
 
 [[items]]
 section = "web"
 name = "motd"
 default = ""
 
 [[items]]
 section = "web"
 name = "name"
 default-type = "dynamic"
 
 [[items]]
 section = "web"
 name = "port"
 default = 8000
 
 [[items]]
 section = "web"
 name = "prefix"
 default = ""
 
 [[items]]
 section = "web"
 name = "push_ssl"
 default = true
 
 [[items]]
 section = "web"
 name = "refreshinterval"
 default = 20
 
 [[items]]
 section = "web"
 name = "server-header"
 
 [[items]]
 section = "web"
 name = "static"
 
 [[items]]
 section = "web"
 name = "staticurl"
 
 [[items]]
 section = "web"
 name = "stripes"
 default = 1
 
 [[items]]
 section = "web"
 name = "style"
 default = "paper"
 
 [[items]]
 section = "web"
 name = "templates"
 
 [[items]]
 section = "web"
 name = "view"
 default = "served"
 experimental = true
 
 [[items]]
 section = "worker"
 name = "backgroundclose"
 default-type = "dynamic"
 
 [[items]]
 section = "worker"
 name = "backgroundclosemaxqueue"
 # Windows defaults to a limit of 512 open files. A buffer of 128
 # should give us enough headway.
 default = 384
 
 [[items]]
 section = "worker"
 name = "backgroundcloseminfilecount"
 default = 2048
 
 [[items]]
 section = "worker"
 name = "backgroundclosethreadcount"
 default = 4
 
 [[items]]
 section = "worker"
 name = "enabled"
 default = true
 
 [[items]]
 section = "worker"
 name = "numcpus"
 
 # Templates and template applications
 
 [[template-applications]]
 template = "diff-options"
 section = "annotate"
 
 [[template-applications]]
 template = "diff-options"
 section = "commands"
 prefix = "commit.interactive"
 
 [[template-applications]]
 template = "diff-options"
 section = "commands"
 prefix = "revert.interactive"
 
 [[template-applications]]
 template = "diff-options"
 section = "diff"
 
 [templates]
 [[templates.diff-options]]
 suffix = "nodates"
 default = false
 
 [[templates.diff-options]]
 suffix = "showfunc"
 default = false
 
 [[templates.diff-options]]
 suffix = "unified"
 
 [[templates.diff-options]]
 suffix = "git"
 default = false
 
 [[templates.diff-options]]
 suffix = "ignorews"
 default = false
 
 [[templates.diff-options]]
 suffix = "ignorewsamount"
 default = false
 
 [[templates.diff-options]]
 suffix = "ignoreblanklines"
 default = false
 
 [[templates.diff-options]]
 suffix = "ignorewseol"
 default = false
 
 [[templates.diff-options]]
 suffix = "nobinary"
 default = false
 
 [[templates.diff-options]]
 suffix = "noprefix"
 default = false
 
 [[templates.diff-options]]
 suffix = "word-diff"
 default = false
 
 # In-core extensions
 
 [[items]]
 section = "blackbox"
+name = "debug.to-stderr"
+default = false
+in_core_extension = "blackbox"
+
+[[items]]
+section = "blackbox"
 name = "dirty"
 default = false
 in_core_extension = "blackbox"
 
 [[items]]
 section = "blackbox"
 name = "maxsize"
 default = "1 MB"
 in_core_extension = "blackbox"
 
 [[items]]
 section = "blackbox"
 name = "logsource"
 default = false
 in_core_extension = "blackbox"
 
 [[items]]
 section = "blackbox"
 name = "maxfiles"
 default = 7
 in_core_extension = "blackbox"
 
 [[items]]
 section = "blackbox"
 name = "track"
 default-type = "lambda"
 default = ["*"]
 in_core_extension = "blackbox"
 
 [[items]]
 section = "blackbox"
 name = "ignore"
 default-type = "lambda"
 default = ["chgserver", "cmdserver", "extension"]
 in_core_extension = "blackbox"
 
 [[items]]
 section = "blackbox"
 name = "date-format"
 default = ""
 in_core_extension = "blackbox"

mercurial/httppeer.py

@@ -1,669 +1,670 b''
 # httppeer.py - HTTP repository proxy classes for mercurial
 #
 # Copyright 2005, 2006 Olivia Mackall <[e-mail]>
 # Copyright 2006 Vadim Gelfer <[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.
 
 
 import errno
 import io
 import os
 import socket
 import struct
 
 from concurrent import futures
 from .i18n import _
 from . import (
     bundle2,
     error,
     httpconnection,
     pycompat,
     statichttprepo,
     url as urlmod,
     util,
     wireprotov1peer,
 )
 from .utils import urlutil
 
 httplib = util.httplib
 urlerr = util.urlerr
 urlreq = util.urlreq
 
 
 def encodevalueinheaders(value, header, limit):
     """Encode a string value into multiple HTTP headers.
 
     ``value`` will be encoded into 1 or more HTTP headers with the names
     ``header-<N>`` where ``<N>`` is an integer starting at 1. Each header
     name + value will be at most ``limit`` bytes long.
 
     Returns an iterable of 2-tuples consisting of header names and
     values as native strings.
     """
     # HTTP Headers are ASCII. Python 3 requires them to be unicodes,
     # not bytes. This function always takes bytes in as arguments.
     fmt = pycompat.strurl(header) + r'-%s'
     # Note: it is *NOT* a bug that the last bit here is a bytestring
     # and not a unicode: we're just getting the encoded length anyway,
     # and using an r-string to make it portable between Python 2 and 3
     # doesn't work because then the \r is a literal backslash-r
     # instead of a carriage return.
     valuelen = limit - len(fmt % '000') - len(b': \r\n')
     result = []
 
     n = 0
     for i in range(0, len(value), valuelen):
         n += 1
         result.append((fmt % str(n), pycompat.strurl(value[i : i + valuelen])))
 
     return result
 
 
 class _multifile:
     def __init__(self, *fileobjs):
         for f in fileobjs:
             if not hasattr(f, 'length'):
                 raise ValueError(
                     b'_multifile only supports file objects that '
                     b'have a length but this one does not:',
                     type(f),
                     f,
                 )
         self._fileobjs = fileobjs
         self._index = 0
 
     @property
     def length(self):
         return sum(f.length for f in self._fileobjs)
 
     def read(self, amt=None):
         if amt <= 0:
             return b''.join(f.read() for f in self._fileobjs)
         parts = []
         while amt and self._index < len(self._fileobjs):
             parts.append(self._fileobjs[self._index].read(amt))
             got = len(parts[-1])
             if got < amt:
                 self._index += 1
             amt -= got
         return b''.join(parts)
 
     def seek(self, offset, whence=os.SEEK_SET):
         if whence != os.SEEK_SET:
             raise NotImplementedError(
                 b'_multifile does not support anything other'
                 b' than os.SEEK_SET for whence on seek()'
             )
         if offset != 0:
             raise NotImplementedError(
                 b'_multifile only supports seeking to start, but that '
                 b'could be fixed if you need it'
             )
         for f in self._fileobjs:
             f.seek(0)
         self._index = 0
 
 
 def makev1commandrequest(
     ui,
     requestbuilder,
     caps,
     capablefn,
     repobaseurl,
     cmd,
     args,
     remotehidden=False,
 ):
     """Make an HTTP request to run a command for a version 1 client.
 
     ``caps`` is a set of known server capabilities. The value may be
     None if capabilities are not yet known.
 
     ``capablefn`` is a function to evaluate a capability.
 
     ``cmd``, ``args``, and ``data`` define the command, its arguments, and
     raw data to pass to it.
     """
     if cmd == b'pushkey':
         args[b'data'] = b''
     data = args.pop(b'data', None)
     headers = args.pop(b'headers', {})
 
     ui.debug(b"sending %s command\n" % cmd)
     q = [(b'cmd', cmd)]
     if remotehidden:
         q.append(('access-hidden', '1'))
     headersize = 0
     # Important: don't use self.capable() here or else you end up
     # with infinite recursion when trying to look up capabilities
     # for the first time.
     postargsok = caps is not None and b'httppostargs' in caps
 
     # Send arguments via POST.
     if postargsok and args:
         strargs = urlreq.urlencode(sorted(args.items()))
         if not data:
             data = strargs
         else:
             if isinstance(data, bytes):
                 i = io.BytesIO(data)
                 i.length = len(data)
                 data = i
             argsio = io.BytesIO(strargs)
             argsio.length = len(strargs)
             data = _multifile(argsio, data)
         headers['X-HgArgs-Post'] = len(strargs)
     elif args:
         # Calling self.capable() can infinite loop if we are calling
         # "capabilities". But that command should never accept wire
         # protocol arguments. So this should never happen.
         assert cmd != b'capabilities'
         httpheader = capablefn(b'httpheader')
         if httpheader:
             headersize = int(httpheader.split(b',', 1)[0])
 
         # Send arguments via HTTP headers.
         if headersize > 0:
             # The headers can typically carry more data than the URL.
             encoded_args = urlreq.urlencode(sorted(args.items()))
             for header, value in encodevalueinheaders(
                 encoded_args, b'X-HgArg', headersize
             ):
                 headers[header] = value
         # Send arguments via query string (Mercurial <1.9).
         else:
             q += sorted(args.items())
 
     qs = b'?%s' % urlreq.urlencode(q)
     cu = b"%s%s" % (repobaseurl, qs)
     size = 0
     if hasattr(data, 'length'):
         size = data.length
     elif data is not None:
         size = len(data)
     if data is not None and 'Content-Type' not in headers:
         headers['Content-Type'] = 'application/mercurial-0.1'
 
     # Tell the server we accept application/mercurial-0.2 and multiple
     # compression formats if the server is capable of emitting those
     # payloads.
     # Note: Keep this set empty by default, as client advertisement of
     # protocol parameters should only occur after the handshake.
     protoparams = set()
 
     mediatypes = set()
     if caps is not None:
         mt = capablefn(b'httpmediatype')
         if mt:
             protoparams.add(b'0.1')
             mediatypes = set(mt.split(b','))
 
         protoparams.add(b'partial-pull')
 
     if b'0.2tx' in mediatypes:
         protoparams.add(b'0.2')
 
     if b'0.2tx' in mediatypes and capablefn(b'compression'):
         # We /could/ compare supported compression formats and prune
         # non-mutually supported or error if nothing is mutually supported.
         # For now, send the full list to the server and have it error.
         comps = [
             e.wireprotosupport().name
             for e in util.compengines.supportedwireengines(util.CLIENTROLE)
         ]
         protoparams.add(b'comp=%s' % b','.join(comps))
 
     if protoparams:
         protoheaders = encodevalueinheaders(
             b' '.join(sorted(protoparams)), b'X-HgProto', headersize or 1024
         )
         for header, value in protoheaders:
             headers[header] = value
 
     varyheaders = []
     for header in headers:
         if header.lower().startswith('x-hg'):
             varyheaders.append(header)
 
     if varyheaders:
         headers['Vary'] = ','.join(sorted(varyheaders))
 
     req = requestbuilder(pycompat.strurl(cu), data, headers)
 
     if data is not None:
         ui.debug(b"sending %d bytes\n" % size)
         req.add_unredirected_header('Content-Length', '%d' % size)
 
     return req, cu, qs
 
 
 def sendrequest(ui, opener, req):
     """Send a prepared HTTP request.
 
     Returns the response object.
     """
     dbg = ui.debug
     if ui.debugflag and ui.configbool(b'devel', b'debug.peer-request'):
         line = b'devel-peer-request: %s\n'
         dbg(
             line
             % b'%s %s'
             % (
                 pycompat.bytesurl(req.get_method()),
                 pycompat.bytesurl(req.get_full_url()),
             )
         )
         hgargssize = None
 
         for header, value in sorted(req.header_items()):
             header = pycompat.bytesurl(header)
             value = pycompat.bytesurl(value)
             if header.startswith(b'X-hgarg-'):
                 if hgargssize is None:
                     hgargssize = 0
                 hgargssize += len(value)
             else:
                 dbg(line % b'  %s %s' % (header, value))
 
         if hgargssize is not None:
             dbg(
                 line
                 % b'  %d bytes of commands arguments in headers'
                 % hgargssize
             )
         data = req.data
         if data is not None:
             length = getattr(data, 'length', None)
             if length is None:
                 length = len(data)
             dbg(line % b'  %d bytes of data' % length)
 
         start = util.timer()
 
     res = None
     try:
         res = opener.open(req)
     except urlerr.httperror as inst:
         if inst.code == 401:
             raise error.Abort(_(b'authorization failed'))
         raise
     except httplib.HTTPException as inst:
         ui.debug(
             b'http error requesting %s\n'
             % urlutil.hidepassword(req.get_full_url())
         )
         ui.traceback()
         raise IOError(None, inst)
     finally:
         if ui.debugflag and ui.configbool(b'devel', b'debug.peer-request'):
             code = res.code if res else -1
             dbg(
                 line
                 % b'  finished in %.4f seconds (%d)'
                 % (util.timer() - start, code)
             )
 
     # Insert error handlers for common I/O failures.
     urlmod.wrapresponse(res)
 
     return res
 
 
 class RedirectedRepoError(error.RepoError):
     def __init__(self, msg, respurl):
         super(RedirectedRepoError, self).__init__(msg)
         self.respurl = respurl
 
 
 def parsev1commandresponse(ui, baseurl, requrl, qs, resp, compressible):
     # record the url we got redirected to
     redirected = False
     respurl = pycompat.bytesurl(resp.geturl())
     if respurl.endswith(qs):
         respurl = respurl[: -len(qs)]
         qsdropped = False
     else:
         qsdropped = True
 
     if baseurl.rstrip(b'/') != respurl.rstrip(b'/'):
         redirected = True
         if not ui.quiet:
             ui.warn(_(b'real URL is %s\n') % respurl)
 
     try:
         proto = pycompat.bytesurl(resp.getheader('content-type', ''))
     except AttributeError:
         proto = pycompat.bytesurl(resp.headers.get('content-type', ''))
 
     safeurl = urlutil.hidepassword(baseurl)
     if proto.startswith(b'application/hg-error'):
         raise error.OutOfBandError(resp.read())
 
     # Pre 1.0 versions of Mercurial used text/plain and
     # application/hg-changegroup. We don't support such old servers.
     if not proto.startswith(b'application/mercurial-'):
         ui.debug(b"requested URL: '%s'\n" % urlutil.hidepassword(requrl))
         msg = _(
             b"'%s' does not appear to be an hg repository:\n"
             b"---%%<--- (%s)\n%s\n---%%<---\n"
         ) % (safeurl, proto or b'no content-type', resp.read(1024))
 
         # Some servers may strip the query string from the redirect. We
         # raise a special error type so callers can react to this specially.
         if redirected and qsdropped:
             raise RedirectedRepoError(msg, respurl)
         else:
             raise error.RepoError(msg)
 
     try:
         subtype = proto.split(b'-', 1)[1]
 
         version_info = tuple([int(n) for n in subtype.split(b'.')])
     except ValueError:
         raise error.RepoError(
             _(b"'%s' sent a broken Content-Type header (%s)") % (safeurl, proto)
         )
 
     # TODO consider switching to a decompression reader that uses
     # generators.
     if version_info == (0, 1):
         if compressible:
             resp = util.compengines[b'zlib'].decompressorreader(resp)
 
     elif version_info == (0, 2):
         # application/mercurial-0.2 always identifies the compression
         # engine in the payload header.
         elen = struct.unpack(b'B', util.readexactly(resp, 1))[0]
         ename = util.readexactly(resp, elen)
         engine = util.compengines.forwiretype(ename)
 
         resp = engine.decompressorreader(resp)
     else:
         raise error.RepoError(
             _(b"'%s' uses newer protocol %s") % (safeurl, subtype)
         )
 
     return respurl, proto, resp
 
 
 class httppeer(wireprotov1peer.wirepeer):
     def __init__(
         self, ui, path, url, opener, requestbuilder, caps, remotehidden=False
     ):
         super().__init__(ui, path=path, remotehidden=remotehidden)
         self._url = url
         self._caps = caps
         self.limitedarguments = caps is not None and b'httppostargs' not in caps
         self._urlopener = opener
         self._requestbuilder = requestbuilder
         self._remotehidden = remotehidden
 
     def __del__(self):
         for h in self._urlopener.handlers:
             h.close()
             getattr(h, "close_all", lambda: None)()
 
     # Begin of ipeerconnection interface.
 
     def url(self):
         return self.path.loc
 
     def local(self):
         return None
 
     def canpush(self):
         return True
 
     def close(self):
         try:
             reqs, sent, recv = (
                 self._urlopener.requestscount,
                 self._urlopener.sentbytescount,
                 self._urlopener.receivedbytescount,
             )
         except AttributeError:
             return
         self.ui.note(
             _(
                 b'(sent %d HTTP requests and %d bytes; '
                 b'received %d bytes in responses)\n'
             )
             % (reqs, sent, recv)
         )
 
     # End of ipeerconnection interface.
 
     # Begin of ipeercommands interface.
 
     def capabilities(self):
         return self._caps
 
     def _finish_inline_clone_bundle(self, stream):
         # HTTP streams must hit the end to process the last empty
         # chunk of Chunked-Encoding so the connection can be reused.
         chunk = stream.read(1)
         if chunk:
             self._abort(error.ResponseError(_(b"unexpected response:"), chunk))
 
     # End of ipeercommands interface.
 
     def _callstream(self, cmd, _compressible=False, **args):
         args = pycompat.byteskwargs(args)
 
         req, cu, qs = makev1commandrequest(
             self.ui,
             self._requestbuilder,
             self._caps,
             self.capable,
             self._url,
             cmd,
             args,
             self._remotehidden,
         )
 
         resp = sendrequest(self.ui, self._urlopener, req)
 
         self._url, ct, resp = parsev1commandresponse(
             self.ui, self._url, cu, qs, resp, _compressible
         )
 
         return resp
 
     def _call(self, cmd, **args):
         fp = self._callstream(cmd, **args)
         try:
             return fp.read()
         finally:
             # if using keepalive, allow connection to be reused
             fp.close()
 
     def _callpush(self, cmd, cg, **args):
         # have to stream bundle to a temp file because we do not have
         # http 1.1 chunked transfer.
 
         types = self.capable(b'unbundle')
         try:
             types = types.split(b',')
         except AttributeError:
             # servers older than d1b16a746db6 will send 'unbundle' as a
             # boolean capability. They only support headerless/uncompressed
             # bundles.
             types = [b""]
         for x in types:
             if x in bundle2.bundletypes:
                 type = x
                 break
 
         tempname = bundle2.writebundle(self.ui, cg, None, type)
         fp = httpconnection.httpsendfile(self.ui, tempname, b"rb")
         headers = {'Content-Type': 'application/mercurial-0.1'}
 
         try:
             r = self._call(cmd, data=fp, headers=headers, **args)
             vals = r.split(b'\n', 1)
             if len(vals) < 2:
                 raise error.ResponseError(_(b"unexpected response:"), r)
             return vals
         except urlerr.httperror:
             # Catch and re-raise these so we don't try and treat them
             # like generic socket errors. They lack any values in
             # .args on Python 3 which breaks our socket.error block.
             raise
         except socket.error as err:
             if err.args[0] in (errno.ECONNRESET, errno.EPIPE):
                 raise error.Abort(_(b'push failed: %s') % err.args[1])
             raise error.Abort(err.args[1])
         finally:
             fp.close()
             os.unlink(tempname)
 
     def _calltwowaystream(self, cmd, fp, **args):
         filename = None
         try:
             # dump bundle to disk
             fd, filename = pycompat.mkstemp(prefix=b"hg-bundle-", suffix=b".hg")
             with os.fdopen(fd, "wb") as fh:
                 d = fp.read(4096)
                 while d:
                     fh.write(d)
                     d = fp.read(4096)
             # start http push
             with httpconnection.httpsendfile(self.ui, filename, b"rb") as fp_:
                 headers = {'Content-Type': 'application/mercurial-0.1'}
                 return self._callstream(cmd, data=fp_, headers=headers, **args)
         finally:
             if filename is not None:
                 os.unlink(filename)
 
     def _callcompressable(self, cmd, **args):
         return self._callstream(cmd, _compressible=True, **args)
 
     def _abort(self, exception):
         raise exception
 
 
 class queuedcommandfuture(futures.Future):
     """Wraps result() on command futures to trigger submission on call."""
 
     def result(self, timeout=None):
         if self.done():
             return futures.Future.result(self, timeout)
 
         self._peerexecutor.sendcommands()
 
         # sendcommands() will restore the original __class__ and self.result
         # will resolve to Future.result.
         return self.result(timeout)
 
 
 def performhandshake(ui, url, opener, requestbuilder):
     # The handshake is a request to the capabilities command.
 
     caps = None
 
     def capable(x):
         raise error.ProgrammingError(b'should not be called')
 
     args = {}
 
     req, requrl, qs = makev1commandrequest(
         ui, requestbuilder, caps, capable, url, b'capabilities', args
     )
     resp = sendrequest(ui, opener, req)
 
     # The server may redirect us to the repo root, stripping the
     # ?cmd=capabilities query string from the URL. The server would likely
     # return HTML in this case and ``parsev1commandresponse()`` would raise.
     # We catch this special case and re-issue the capabilities request against
     # the new URL.
     #
     # We should ideally not do this, as a redirect that drops the query
     # string from the URL is arguably a server bug. (Garbage in, garbage out).
     # However,  Mercurial clients for several years appeared to handle this
     # issue without behavior degradation. And according to issue 5860, it may
     # be a longstanding bug in some server implementations. So we allow a
     # redirect that drops the query string to "just work."
     try:
         respurl, ct, resp = parsev1commandresponse(
             ui, url, requrl, qs, resp, compressible=False
         )
     except RedirectedRepoError as e:
         req, requrl, qs = makev1commandrequest(
             ui, requestbuilder, caps, capable, e.respurl, b'capabilities', args
         )
         resp = sendrequest(ui, opener, req)
         respurl, ct, resp = parsev1commandresponse(
             ui, url, requrl, qs, resp, compressible=False
         )
 
     try:
         rawdata = resp.read()
     finally:
         resp.close()
 
     if not ct.startswith(b'application/mercurial-'):
         raise error.ProgrammingError(b'unexpected content-type: %s' % ct)
 
     info = {b'v1capabilities': set(rawdata.split())}
 
     return respurl, info
 
 
 def _make_peer(
     ui, path, opener=None, requestbuilder=urlreq.request, remotehidden=False
 ):
     """Construct an appropriate HTTP peer instance.
 
     ``opener`` is an ``url.opener`` that should be used to establish
     connections, perform HTTP requests.
 
     ``requestbuilder`` is the type used for constructing HTTP requests.
     It exists as an argument so extensions can override the default.
     """
     if path.url.query or path.url.fragment:
         msg = _(b'unsupported URL component: "%s"')
         msg %= path.url.query or path.url.fragment
         raise error.Abort(msg)
 
     # urllib cannot handle URLs with embedded user or passwd.
     url, authinfo = path.url.authinfo()
     ui.debug(b'using %s\n' % url)
 
     opener = opener or urlmod.opener(ui, authinfo)
 
     respurl, info = performhandshake(ui, url, opener, requestbuilder)
 
     return httppeer(
         ui,
         path,
         respurl,
         opener,
         requestbuilder,
         info[b'v1capabilities'],
         remotehidden=remotehidden,
     )
 
 
 def make_peer(
     ui, path, create, intents=None, createopts=None, remotehidden=False
 ):
     if create:
         raise error.Abort(_(b'cannot create new http repository'))
     try:
         if path.url.scheme == b'https' and not urlmod.has_https:
             raise error.Abort(
                 _(b'Python support for SSL and HTTPS is not installed')
             )
 
         inst = _make_peer(ui, path, remotehidden=remotehidden)
 
         return inst
     except error.RepoError as httpexception:
         try:
-            r = statichttprepo.make_peer(ui, b"static-" + path.loc, create)
+            path = path.copy(new_raw_location=b"static-" + path.rawloc)
+            r = statichttprepo.make_peer(ui, path, create)
             ui.note(_(b'(falling back to static-http)\n'))
             return r
         except error.RepoError:
             raise httpexception  # use the original http RepoError instead

mercurial/tags.py

@@ -1,912 +1,932 b''
 # tags.py - read tag info from local repository
 #
 # Copyright 2009 Olivia Mackall <[e-mail]>
 # Copyright 2009 Greg Ward <[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.
 
 # Currently this module only deals with reading and caching tags.
 # Eventually, it could take care of updating (adding/removing/moving)
 # tags too.
 
 
 import binascii
 import io
 
 from .node import (
     bin,
     hex,
     nullrev,
     short,
 )
 from .i18n import _
 from . import (
     encoding,
     error,
     match as matchmod,
     scmutil,
     util,
 )
 from .utils import stringutil
 
 # Tags computation can be expensive and caches exist to make it fast in
 # the common case.
 #
 # The "hgtagsfnodes1" cache file caches the .hgtags filenode values for
 # each revision in the repository. The file is effectively an array of
 # fixed length records. Read the docs for "hgtagsfnodescache" for technical
 # details.
 #
 # The .hgtags filenode cache grows in proportion to the length of the
 # changelog. The file is truncated when the # changelog is stripped.
 #
 # The purpose of the filenode cache is to avoid the most expensive part
 # of finding global tags, which is looking up the .hgtags filenode in the
 # manifest for each head. This can take dozens or over 100ms for
 # repositories with very large manifests. Multiplied by dozens or even
 # hundreds of heads and there is a significant performance concern.
 #
 # There also exist a separate cache file for each repository filter.
 # These "tags-*" files store information about the history of tags.
 #
 # The tags cache files consists of a cache validation line followed by
 # a history of tags.
 #
 # The cache validation line has the format:
 #
 #   <tiprev> <tipnode> [<filteredhash>]
 #
 # <tiprev> is an integer revision and <tipnode> is a 40 character hex
 # node for that changeset. These redundantly identify the repository
 # tip from the time the cache was written. In addition, <filteredhash>,
 # if present, is a 40 character hex hash of the contents of the filtered
 # revisions for this filter. If the set of filtered revs changes, the
 # hash will change and invalidate the cache.
 #
 # The history part of the tags cache consists of lines of the form:
 #
 #   <node> <tag>
 #
 # (This format is identical to that of .hgtags files.)
 #
 # <tag> is the tag name and <node> is the 40 character hex changeset
 # the tag is associated with.
 #
 # Tags are written sorted by tag name.
 #
 # Tags associated with multiple changesets have an entry for each changeset.
 # The most recent changeset (in terms of revlog ordering for the head
 # setting it) for each tag is last.
 
 
 def fnoderevs(ui, repo, revs):
     """return the list of '.hgtags' fnodes used in a set revisions
 
     This is returned as list of unique fnodes. We use a list instead of a set
     because order matters when it comes to tags."""
     unfi = repo.unfiltered()
     tonode = unfi.changelog.node
     nodes = [tonode(r) for r in revs]
     fnodes = _getfnodes(ui, repo, nodes)
     fnodes = _filterfnodes(fnodes, nodes)
     return fnodes
 
 
 def _nulltonone(repo, value):
     """convert nullid to None
 
     For tag value, nullid means "deleted". This small utility function helps
     translating that to None."""
     if value == repo.nullid:
         return None
     return value
 
 
 def difftags(ui, repo, oldfnodes, newfnodes):
     """list differences between tags expressed in two set of file-nodes
 
     The list contains entries in the form: (tagname, oldvalue, new value).
     None is used to expressed missing value:
         ('foo', None, 'abcd') is a new tag,
         ('bar', 'ef01', None) is a deletion,
         ('baz', 'abcd', 'ef01') is a tag movement.
     """
     if oldfnodes == newfnodes:
         return []
     oldtags = _tagsfromfnodes(ui, repo, oldfnodes)
     newtags = _tagsfromfnodes(ui, repo, newfnodes)
 
     # list of (tag, old, new): None means missing
     entries = []
     for tag, (new, __) in newtags.items():
         new = _nulltonone(repo, new)
         old, __ = oldtags.pop(tag, (None, None))
         old = _nulltonone(repo, old)
         if old != new:
             entries.append((tag, old, new))
     # handle deleted tags
     for tag, (old, __) in oldtags.items():
         old = _nulltonone(repo, old)
         if old is not None:
             entries.append((tag, old, None))
     entries.sort()
     return entries
 
 
 def writediff(fp, difflist):
     """write tags diff information to a file.
 
     Data are stored with a line based format:
 
         <action> <hex-node> <tag-name>\n
 
     Action are defined as follow:
        -R tag is removed,
        +A tag is added,
        -M tag is moved (old value),
        +M tag is moved (new value),
 
     Example:
 
          +A 875517b4806a848f942811a315a5bce30804ae85 t5
 
     See documentation of difftags output for details about the input.
     """
     add = b'+A %s %s\n'
     remove = b'-R %s %s\n'
     updateold = b'-M %s %s\n'
     updatenew = b'+M %s %s\n'
     for tag, old, new in difflist:
         # translate to hex
         if old is not None:
             old = hex(old)
         if new is not None:
             new = hex(new)
         # write to file
         if old is None:
             fp.write(add % (new, tag))
         elif new is None:
             fp.write(remove % (old, tag))
         else:
             fp.write(updateold % (old, tag))
             fp.write(updatenew % (new, tag))
 
 
 def findglobaltags(ui, repo):
     """Find global tags in a repo: return a tagsmap
 
     tagsmap: tag name to (node, hist) 2-tuples.
 
     The tags cache is read and updated as a side-effect of calling.
     """
     (heads, tagfnode, valid, cachetags, shouldwrite) = _readtagcache(ui, repo)
     if cachetags is not None:
         assert not shouldwrite
         # XXX is this really 100% correct?  are there oddball special
         # cases where a global tag should outrank a local tag but won't,
         # because cachetags does not contain rank info?
         alltags = {}
         _updatetags(cachetags, alltags)
         return alltags
 
+    has_node = repo.changelog.index.has_node
     for head in reversed(heads):  # oldest to newest
-        assert repo.changelog.index.has_node(
-            head
-        ), b"tag cache returned bogus head %s" % short(head)
+        assert has_node(head), b"tag cache returned bogus head %s" % short(head)
     fnodes = _filterfnodes(tagfnode, reversed(heads))
     alltags = _tagsfromfnodes(ui, repo, fnodes)
 
     # and update the cache (if necessary)
     if shouldwrite:
         _writetagcache(ui, repo, valid, alltags)
     return alltags
 
 
 def _filterfnodes(tagfnode, nodes):
     """return a list of unique fnodes
 
     The order of this list matches the order of "nodes". Preserving this order
     is important as reading tags in different order provides different
     results."""
     seen = set()  # set of fnode
     fnodes = []
     for no in nodes:  # oldest to newest
         fnode = tagfnode.get(no)
         if fnode and fnode not in seen:
             seen.add(fnode)
             fnodes.append(fnode)
     return fnodes
 
 
 def _tagsfromfnodes(ui, repo, fnodes):
     """return a tagsmap from a list of file-node
 
     tagsmap: tag name to (node, hist) 2-tuples.
 
     The order of the list matters."""
     alltags = {}
     fctx = None
     for fnode in fnodes:
         if fctx is None:
             fctx = repo.filectx(b'.hgtags', fileid=fnode)
         else:
             fctx = fctx.filectx(fnode)
         filetags = _readtags(ui, repo, fctx.data().splitlines(), fctx)
         _updatetags(filetags, alltags)
     return alltags
 
 
 def readlocaltags(ui, repo, alltags, tagtypes):
     '''Read local tags in repo. Update alltags and tagtypes.'''
     try:
         data = repo.vfs.read(b"localtags")
     except FileNotFoundError:
         return
 
     # localtags is in the local encoding; re-encode to UTF-8 on
     # input for consistency with the rest of this module.
     filetags = _readtags(
         ui, repo, data.splitlines(), b"localtags", recode=encoding.fromlocal
     )
 
     # remove tags pointing to invalid nodes
     cl = repo.changelog
     for t in list(filetags):
         try:
             cl.rev(filetags[t][0])
         except (LookupError, ValueError):
             del filetags[t]
 
     _updatetags(filetags, alltags, b'local', tagtypes)
 
 
 def _readtaghist(ui, repo, lines, fn, recode=None, calcnodelines=False):
     """Read tag definitions from a file (or any source of lines).
 
     This function returns two sortdicts with similar information:
 
     - the first dict, bintaghist, contains the tag information as expected by
       the _readtags function, i.e. a mapping from tag name to (node, hist):
         - node is the node id from the last line read for that name,
         - hist is the list of node ids previously associated with it (in file
           order). All node ids are binary, not hex.
 
     - the second dict, hextaglines, is a mapping from tag name to a list of
       [hexnode, line number] pairs, ordered from the oldest to the newest node.
 
     When calcnodelines is False the hextaglines dict is not calculated (an
     empty dict is returned). This is done to improve this function's
     performance in cases where the line numbers are not needed.
     """
 
     bintaghist = util.sortdict()
     hextaglines = util.sortdict()
     count = 0
 
     def dbg(msg):
         ui.debug(b"%s, line %d: %s\n" % (fn, count, msg))
 
     for nline, line in enumerate(lines):
         count += 1
         if not line:
             continue
         try:
             (nodehex, name) = line.split(b" ", 1)
         except ValueError:
             dbg(b"cannot parse entry")
             continue
         name = name.strip()
         if recode:
             name = recode(name)
         try:
             nodebin = bin(nodehex)
         except binascii.Error:
             dbg(b"node '%s' is not well formed" % nodehex)
             continue
 
         # update filetags
         if calcnodelines:
             # map tag name to a list of line numbers
             if name not in hextaglines:
                 hextaglines[name] = []
             hextaglines[name].append([nodehex, nline])
             continue
         # map tag name to (node, hist)
         if name not in bintaghist:
             bintaghist[name] = []
         bintaghist[name].append(nodebin)
     return bintaghist, hextaglines
 
 
 def _readtags(ui, repo, lines, fn, recode=None, calcnodelines=False):
     """Read tag definitions from a file (or any source of lines).
 
     Returns a mapping from tag name to (node, hist).
 
     "node" is the node id from the last line read for that name. "hist"
     is the list of node ids previously associated with it (in file order).
     All node ids are binary, not hex.
     """
     filetags, nodelines = _readtaghist(
         ui, repo, lines, fn, recode=recode, calcnodelines=calcnodelines
     )
     # util.sortdict().__setitem__ is much slower at replacing then inserting
     # new entries. The difference can matter if there are thousands of tags.
     # Create a new sortdict to avoid the performance penalty.
     newtags = util.sortdict()
     for tag, taghist in filetags.items():
         newtags[tag] = (taghist[-1], taghist[:-1])
     return newtags
 
 
 def _updatetags(filetags, alltags, tagtype=None, tagtypes=None):
     """Incorporate the tag info read from one file into dictionnaries
 
     The first one, 'alltags', is a "tagmaps" (see 'findglobaltags' for details).
 
     The second one, 'tagtypes', is optional and will be updated to track the
     "tagtype" of entries in the tagmaps. When set, the 'tagtype' argument also
     needs to be set."""
     if tagtype is None:
         assert tagtypes is None
 
     for name, nodehist in filetags.items():
         if name not in alltags:
             alltags[name] = nodehist
             if tagtype is not None:
                 tagtypes[name] = tagtype
             continue
 
         # we prefer alltags[name] if:
         #  it supersedes us OR
         #  mutual supersedes and it has a higher rank
         # otherwise we win because we're tip-most
         anode, ahist = nodehist
         bnode, bhist = alltags[name]
         if (
             bnode != anode
             and anode in bhist
             and (bnode not in ahist or len(bhist) > len(ahist))
         ):
             anode = bnode
         elif tagtype is not None:
             tagtypes[name] = tagtype
         ahist.extend([n for n in bhist if n not in ahist])
         alltags[name] = anode, ahist
 
 
 def _filename(repo):
     """name of a tagcache file for a given repo or repoview"""
     filename = b'tags2'
     if repo.filtername:
         filename = b'%s-%s' % (filename, repo.filtername)
     return filename
 
 
 def _readtagcache(ui, repo):
     """Read the tag cache.
 
     Returns a tuple (heads, fnodes, validinfo, cachetags, shouldwrite).
 
     If the cache is completely up-to-date, "cachetags" is a dict of the
     form returned by _readtags() and "heads", "fnodes", and "validinfo" are
     None and "shouldwrite" is False.
 
     If the cache is not up to date, "cachetags" is None. "heads" is a list
     of all heads currently in the repository, ordered from tip to oldest.
     "validinfo" is a tuple describing cache validation info. This is used
     when writing the tags cache. "fnodes" is a mapping from head to .hgtags
     filenode. "shouldwrite" is True.
 
     If the cache is not up to date, the caller is responsible for reading tag
     info from each returned head. (See findglobaltags().)
     """
     try:
         cachefile = repo.cachevfs(_filename(repo), b'r')
         # force reading the file for static-http
         cachelines = iter(cachefile)
     except IOError:
         cachefile = None
 
     cacherev = None
     cachenode = None
     cachehash = None
     if cachefile:
         try:
             validline = next(cachelines)
             validline = validline.split()
             cacherev = int(validline[0])
             cachenode = bin(validline[1])
             if len(validline) > 2:
                 cachehash = bin(validline[2])
         except Exception:
             # corruption of the cache, just recompute it.
             pass
 
     tipnode = repo.changelog.tip()
     tiprev = len(repo.changelog) - 1
 
     # Case 1 (common): tip is the same, so nothing has changed.
     # (Unchanged tip trivially means no changesets have been added.
     # But, thanks to localrepository.destroyed(), it also means none
     # have been destroyed by strip or rollback.)
     if (
         cacherev == tiprev
         and cachenode == tipnode
         and cachehash == scmutil.filteredhash(repo, tiprev)
     ):
         tags = _readtags(ui, repo, cachelines, cachefile.name)
         cachefile.close()
         return (None, None, None, tags, False)
     if cachefile:
         cachefile.close()  # ignore rest of file
 
     valid = (tiprev, tipnode, scmutil.filteredhash(repo, tiprev))
 
     repoheads = repo.heads()
     # Case 2 (uncommon): empty repo; get out quickly and don't bother
     # writing an empty cache.
     if repoheads == [repo.nullid]:
         return ([], {}, valid, {}, False)
 
     # Case 3 (uncommon): cache file missing or empty.
 
     # Case 4 (uncommon): tip rev decreased.  This should only happen
     # when we're called from localrepository.destroyed().  Refresh the
     # cache so future invocations will not see disappeared heads in the
     # cache.
 
     # Case 5 (common): tip has changed, so we've added/replaced heads.
 
     # As it happens, the code to handle cases 3, 4, 5 is the same.
 
     # N.B. in case 4 (nodes destroyed), "new head" really means "newly
     # exposed".
     if not len(repo.file(b'.hgtags')):
         # No tags have ever been committed, so we can avoid a
         # potentially expensive search.
         return ([], {}, valid, None, True)
 
     # Now we have to lookup the .hgtags filenode for every new head.
     # This is the most expensive part of finding tags, so performance
     # depends primarily on the size of newheads.  Worst case: no cache
     # file, so newheads == repoheads.
     # Reversed order helps the cache ('repoheads' is in descending order)
     cachefnode = _getfnodes(ui, repo, reversed(repoheads))
 
     # Caller has to iterate over all heads, but can use the filenodes in
     # cachefnode to get to each .hgtags revision quickly.
     return (repoheads, cachefnode, valid, None, True)
 
 
 def _getfnodes(ui, repo, nodes):
     """return .hgtags fnodes for a list of changeset nodes
 
     Return value is a {node: fnode} mapping. There will be no entry for nodes
     without a '.hgtags' file.
     """
     starttime = util.timer()
     fnodescache = hgtagsfnodescache(repo.unfiltered())
     cachefnode = {}
     validated_fnodes = set()
     unknown_entries = set()
 
     flog = None
     for node in nodes:
         fnode = fnodescache.getfnode(node)
         if fnode != repo.nullid:
             if fnode not in validated_fnodes:
                 if flog is None:
                     flog = repo.file(b'.hgtags')
                 if flog.hasnode(fnode):
                     validated_fnodes.add(fnode)
                 else:
                     unknown_entries.add(node)
             cachefnode[node] = fnode
 
     if unknown_entries:
         fixed_nodemap = fnodescache.refresh_invalid_nodes(unknown_entries)
         for node, fnode in fixed_nodemap.items():
             if fnode != repo.nullid:
                 cachefnode[node] = fnode
 
     fnodescache.write()
 
     duration = util.timer() - starttime
     ui.log(
         b'tagscache',
         b'%d/%d cache hits/lookups in %0.4f seconds\n',
         fnodescache.hitcount,
         fnodescache.lookupcount,
         duration,
     )
     return cachefnode
 
 
 def _writetagcache(ui, repo, valid, cachetags):
     filename = _filename(repo)
     try:
         cachefile = repo.cachevfs(filename, b'w', atomictemp=True)
     except (OSError, IOError):
         return
 
     ui.log(
         b'tagscache',
         b'writing .hg/cache/%s with %d tags\n',
         filename,
         len(cachetags),
     )
 
     if valid[2]:
         cachefile.write(
             b'%d %s %s\n' % (valid[0], hex(valid[1]), hex(valid[2]))
         )
     else:
         cachefile.write(b'%d %s\n' % (valid[0], hex(valid[1])))
 
     # Tag names in the cache are in UTF-8 -- which is the whole reason
     # we keep them in UTF-8 throughout this module.  If we converted
     # them local encoding on input, we would lose info writing them to
     # the cache.
     for (name, (node, hist)) in sorted(cachetags.items()):
         for n in hist:
             cachefile.write(b"%s %s\n" % (hex(n), name))
         cachefile.write(b"%s %s\n" % (hex(node), name))
 
     try:
         cachefile.close()
     except (OSError, IOError):
         pass
 
 
 def tag(repo, names, node, message, local, user, date, editor=False):
     """tag a revision with one or more symbolic names.
 
     names is a list of strings or, when adding a single tag, names may be a
     string.
 
     if local is True, the tags are stored in a per-repository file.
     otherwise, they are stored in the .hgtags file, and a new
     changeset is committed with the change.
 
     keyword arguments:
 
     local: whether to store tags in non-version-controlled file
     (default False)
 
     message: commit message to use if committing
 
     user: name of user to use if committing
 
     date: date tuple to use if committing"""
 
     if not local:
         m = matchmod.exact([b'.hgtags'])
         st = repo.status(match=m, unknown=True, ignored=True)
         if any(
             (
                 st.modified,
                 st.added,
                 st.removed,
                 st.deleted,
                 st.unknown,
                 st.ignored,
             )
         ):
             raise error.Abort(
                 _(b'working copy of .hgtags is changed'),
                 hint=_(b'please commit .hgtags manually'),
             )
 
     with repo.wlock():
         repo.tags()  # instantiate the cache
         _tag(repo, names, node, message, local, user, date, editor=editor)
 
 
 def _tag(
     repo, names, node, message, local, user, date, extra=None, editor=False
 ):
     if isinstance(names, bytes):
         names = (names,)
 
     branches = repo.branchmap()
     for name in names:
         repo.hook(b'pretag', throw=True, node=hex(node), tag=name, local=local)
         if name in branches:
             repo.ui.warn(
                 _(b"warning: tag %s conflicts with existing branch name\n")
                 % name
             )
 
     def writetags(fp, names, munge, prevtags):
         fp.seek(0, io.SEEK_END)
         if prevtags and not prevtags.endswith(b'\n'):
             fp.write(b'\n')
         for name in names:
             if munge:
                 m = munge(name)
             else:
                 m = name
 
             if repo._tagscache.tagtypes and name in repo._tagscache.tagtypes:
                 old = repo.tags().get(name, repo.nullid)
                 fp.write(b'%s %s\n' % (hex(old), m))
             fp.write(b'%s %s\n' % (hex(node), m))
         fp.close()
 
     prevtags = b''
     if local:
         try:
             fp = repo.vfs(b'localtags', b'r+')
         except IOError:
             fp = repo.vfs(b'localtags', b'a')
         else:
             prevtags = fp.read()
 
         # local tags are stored in the current charset
         writetags(fp, names, None, prevtags)
         for name in names:
             repo.hook(b'tag', node=hex(node), tag=name, local=local)
         return
 
     try:
         fp = repo.wvfs(b'.hgtags', b'rb+')
     except FileNotFoundError:
         fp = repo.wvfs(b'.hgtags', b'ab')
     else:
         prevtags = fp.read()
 
     # committed tags are stored in UTF-8
     writetags(fp, names, encoding.fromlocal, prevtags)
 
     fp.close()
 
     repo.invalidatecaches()
 
     with repo.dirstate.changing_files(repo):
         if b'.hgtags' not in repo.dirstate:
             repo[None].add([b'.hgtags'])
 
     m = matchmod.exact([b'.hgtags'])
     tagnode = repo.commit(
         message, user, date, extra=extra, match=m, editor=editor
     )
 
     for name in names:
         repo.hook(b'tag', node=hex(node), tag=name, local=local)
 
     return tagnode
 
 
 _fnodescachefile = b'hgtagsfnodes1'
 _fnodesrecsize = 4 + 20  # changeset fragment + filenode
 _fnodesmissingrec = b'\xff' * 24
 
 
 class hgtagsfnodescache:
     """Persistent cache mapping revisions to .hgtags filenodes.
 
     The cache is an array of records. Each item in the array corresponds to
     a changelog revision. Values in the array contain the first 4 bytes of
     the node hash and the 20 bytes .hgtags filenode for that revision.
 
     The first 4 bytes are present as a form of verification. Repository
     stripping and rewriting may change the node at a numeric revision in the
     changelog. The changeset fragment serves as a verifier to detect
     rewriting. This logic is shared with the rev branch cache (see
     branchmap.py).
 
     The instance holds in memory the full cache content but entries are
     only parsed on read.
 
     Instances behave like lists. ``c[i]`` works where i is a rev or
     changeset node. Missing indexes are populated automatically on access.
     """
 
     def __init__(self, repo):
         assert repo.filtername is None
 
         self._repo = repo
 
         # Only for reporting purposes.
         self.lookupcount = 0
         self.hitcount = 0
 
         try:
             data = repo.cachevfs.read(_fnodescachefile)
         except (OSError, IOError):
             data = b""
         self._raw = bytearray(data)
 
         # The end state of self._raw is an array that is of the exact length
         # required to hold a record for every revision in the repository.
         # We truncate or extend the array as necessary. self._dirtyoffset is
         # defined to be the start offset at which we need to write the output
         # file. This offset is also adjusted when new entries are calculated
         # for array members.
         cllen = len(repo.changelog)
         wantedlen = cllen * _fnodesrecsize
         rawlen = len(self._raw)
 
         self._dirtyoffset = None
 
         rawlentokeep = min(
             wantedlen, (rawlen // _fnodesrecsize) * _fnodesrecsize
         )
         if rawlen > rawlentokeep:
             # There's no easy way to truncate array instances. This seems
             # slightly less evil than copying a potentially large array slice.
             for i in range(rawlen - rawlentokeep):
                 self._raw.pop()
             rawlen = len(self._raw)
             self._dirtyoffset = rawlen
         if rawlen < wantedlen:
             if self._dirtyoffset is None:
                 self._dirtyoffset = rawlen
             # TODO: zero fill entire record, because it's invalid not missing?
             self._raw.extend(b'\xff' * (wantedlen - rawlen))
 
     def getfnode(self, node, computemissing=True):
         """Obtain the filenode of the .hgtags file at a specified revision.
 
         If the value is in the cache, the entry will be validated and returned.
         Otherwise, the filenode will be computed and returned unless
         "computemissing" is False.  In that case, None will be returned if
         the entry is missing or False if the entry is invalid without
         any potentially expensive computation being performed.
 
         If an .hgtags does not exist at the specified revision, nullid is
         returned.
         """
         if node == self._repo.nullid:
             return node
 
         rev = self._repo.changelog.rev(node)
 
         self.lookupcount += 1
 
         offset = rev * _fnodesrecsize
         record = b'%s' % self._raw[offset : offset + _fnodesrecsize]
         properprefix = node[0:4]
 
         # Validate and return existing entry.
         if record != _fnodesmissingrec and len(record) == _fnodesrecsize:
             fileprefix = record[0:4]
 
             if fileprefix == properprefix:
                 self.hitcount += 1
                 return record[4:]
 
             # Fall through.
 
         # If we get here, the entry is either missing or invalid.
 
         if not computemissing:
             if record != _fnodesmissingrec:
                 return False
             return None
 
         fnode = self._computefnode(node)
         self._writeentry(offset, properprefix, fnode)
         return fnode
 
     def _computefnode(self, node):
         """Finds the tag filenode for a node which is missing or invalid
         in cache"""
         ctx = self._repo[node]
         rev = ctx.rev()
         fnode = None
         cl = self._repo.changelog
         p1rev, p2rev = cl._uncheckedparentrevs(rev)
         p1node = cl.node(p1rev)
         p1fnode = self.getfnode(p1node, computemissing=False)
         if p2rev != nullrev:
             # There is some no-merge changeset where p1 is null and p2 is set
             # Processing them as merge is just slower, but still gives a good
             # result.
             p2node = cl.node(p2rev)
             p2fnode = self.getfnode(p2node, computemissing=False)
             if p1fnode != p2fnode:
                 # we cannot rely on readfast because we don't know against what
                 # parent the readfast delta is computed
                 p1fnode = None
         if p1fnode:
             mctx = ctx.manifestctx()
             fnode = mctx.readfast().get(b'.hgtags')
             if fnode is None:
                 fnode = p1fnode
         if fnode is None:
             # Populate missing entry.
             try:
                 fnode = ctx.filenode(b'.hgtags')
             except error.LookupError:
                 # No .hgtags file on this revision.
                 fnode = self._repo.nullid
         return fnode
 
     def setfnode(self, node, fnode):
         """Set the .hgtags filenode for a given changeset."""
         assert len(fnode) == 20
         ctx = self._repo[node]
 
         # Do a lookup first to avoid writing if nothing has changed.
         if self.getfnode(ctx.node(), computemissing=False) == fnode:
             return
 
         self._writeentry(ctx.rev() * _fnodesrecsize, node[0:4], fnode)
 
     def refresh_invalid_nodes(self, nodes):
         """recomputes file nodes for a given set of nodes which has unknown
         filenodes for them in the cache
         Also updates the in-memory cache with the correct filenode.
         Caller needs to take care about calling `.write()` so that updates are
         persisted.
         Returns a map {node: recomputed fnode}
         """
         fixed_nodemap = {}
         for node in nodes:
             fnode = self._computefnode(node)
             fixed_nodemap[node] = fnode
             self.setfnode(node, fnode)
         return fixed_nodemap
 
     def _writeentry(self, offset, prefix, fnode):
         # Slices on array instances only accept other array.
         entry = bytearray(prefix + fnode)
         self._raw[offset : offset + _fnodesrecsize] = entry
         # self._dirtyoffset could be None.
         self._dirtyoffset = min(self._dirtyoffset or 0, offset or 0)
 
     def write(self):
         """Perform all necessary writes to cache file.
 
         This may no-op if no writes are needed or if a write lock could
         not be obtained.
         """
         if self._dirtyoffset is None:
             return
 
         data = self._raw[self._dirtyoffset :]
         if not data:
             return
 
         repo = self._repo
 
         try:
             lock = repo.lock(wait=False)
         except error.LockError:
             repo.ui.log(
                 b'tagscache',
                 b'not writing .hg/cache/%s because '
                 b'lock cannot be acquired\n' % _fnodescachefile,
             )
             return
 
         try:
             f = repo.cachevfs.open(_fnodescachefile, b'ab')
             try:
                 # if the file has been truncated
                 actualoffset = f.tell()
                 if actualoffset < self._dirtyoffset:
                     self._dirtyoffset = actualoffset
                     data = self._raw[self._dirtyoffset :]
                 f.seek(self._dirtyoffset)
                 f.truncate()
                 repo.ui.log(
                     b'tagscache',
                     b'writing %d bytes to cache/%s\n'
                     % (len(data), _fnodescachefile),
                 )
                 f.write(data)
                 self._dirtyoffset = None
             finally:
                 f.close()
         except (IOError, OSError) as inst:
             repo.ui.log(
                 b'tagscache',
                 b"couldn't write cache/%s: %s\n"
                 % (_fnodescachefile, stringutil.forcebytestr(inst)),
             )
         finally:
             lock.release()
+
+
+def clear_cache_on_disk(repo):
+    """function used by the perf extension to "tags" cache"""
+    repo.cachevfs.tryunlink(_filename(repo))
+
+
+def clear_cache_fnodes(repo):
+    """function used by the perf extension to clear "file node cache"""
+    repo.cachevfs.tryunlink(_filename(repo))
+
+
+def forget_fnodes(repo, revs):
+    """function used by the perf extension to prune some entries from the fnodes
+    cache"""
+    missing_1 = b'\xff' * 4
+    missing_2 = b'\xff' * 20
+    cache = hgtagsfnodescache(repo.unfiltered())
+    for r in revs:
+        cache._writeentry(r * _fnodesrecsize, missing_1, missing_2)
+    cache.write()

mercurial/upgrade_utils/actions.py

@@ -1,1122 +1,1121 b''
 # upgrade.py - functions for in place upgrade of Mercurial repository
 #
 # Copyright (c) 2016-present, Gregory Szorc
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 from ..i18n import _
 from .. import (
     error,
     localrepo,
     pycompat,
     requirements,
     revlog,
     util,
 )
 
 from ..utils import compression
 
 if pycompat.TYPE_CHECKING:
     from typing import (
         List,
         Type,
     )
 
 
 # list of requirements that request a clone of all revlog if added/removed
 RECLONES_REQUIREMENTS = {
     requirements.GENERALDELTA_REQUIREMENT,
     requirements.SPARSEREVLOG_REQUIREMENT,
     requirements.REVLOGV2_REQUIREMENT,
     requirements.CHANGELOGV2_REQUIREMENT,
 }
 
 
 def preservedrequirements(repo):
     preserved = {
         requirements.SHARED_REQUIREMENT,
         requirements.NARROW_REQUIREMENT,
     }
     return preserved & repo.requirements
 
 
 FORMAT_VARIANT = b'deficiency'
 OPTIMISATION = b'optimization'
 
 
 class improvement:
     """Represents an improvement that can be made as part of an upgrade."""
 
     ### The following attributes should be defined for each subclass:
 
     # Either ``FORMAT_VARIANT`` or ``OPTIMISATION``.
     # A format variant is where we change the storage format. Not all format
     # variant changes are an obvious problem.
     # An optimization is an action (sometimes optional) that
     # can be taken to further improve the state of the repository.
     type = None
 
     # machine-readable string uniquely identifying this improvement. it will be
     # mapped to an action later in the upgrade process.
     name = None
 
     # message intended for humans explaining the improvement in more detail,
     # including the implications of it ``FORMAT_VARIANT`` types, should be
     # worded
     # in the present tense.
     description = None
 
     # message intended for humans explaining what an upgrade addressing this
     # issue will do. should be worded in the future tense.
     upgrademessage = None
 
     # value of current Mercurial default for new repository
     default = None
 
     # Message intended for humans which will be shown post an upgrade
     # operation when the improvement will be added
     postupgrademessage = None
 
     # Message intended for humans which will be shown post an upgrade
     # operation in which this improvement was removed
     postdowngrademessage = None
 
     # By default we assume that every improvement touches requirements and all revlogs
 
     # Whether this improvement touches filelogs
     touches_filelogs = True
 
     # Whether this improvement touches manifests
     touches_manifests = True
 
     # Whether this improvement touches changelog
     touches_changelog = True
 
     # Whether this improvement changes repository requirements
     touches_requirements = True
 
     # Whether this improvement touches the dirstate
     touches_dirstate = False
 
     # Can this action be run on a share instead of its mains repository
     compatible_with_share = False
 
 
 allformatvariant = []  # type: List[Type['formatvariant']]
 
 
 def registerformatvariant(cls):
     allformatvariant.append(cls)
     return cls
 
 
 class formatvariant(improvement):
     """an improvement subclass dedicated to repository format"""
 
     type = FORMAT_VARIANT
 
     @staticmethod
     def fromrepo(repo):
         """current value of the variant in the repository"""
         raise NotImplementedError()
 
     @staticmethod
     def fromconfig(repo):
         """current value of the variant in the configuration"""
         raise NotImplementedError()
 
 
 class requirementformatvariant(formatvariant):
     """formatvariant based on a 'requirement' name.
 
     Many format variant are controlled by a 'requirement'. We define a small
     subclass to factor the code.
     """
 
     # the requirement that control this format variant
     _requirement = None
 
     @staticmethod
     def _newreporequirements(ui):
         return localrepo.newreporequirements(
             ui, localrepo.defaultcreateopts(ui)
         )
 
     @classmethod
     def fromrepo(cls, repo):
         assert cls._requirement is not None
         return cls._requirement in repo.requirements
 
     @classmethod
     def fromconfig(cls, repo):
         assert cls._requirement is not None
         return cls._requirement in cls._newreporequirements(repo.ui)
 
 
 @registerformatvariant
 class fncache(requirementformatvariant):
     name = b'fncache'
 
     _requirement = requirements.FNCACHE_REQUIREMENT
 
     default = True
 
     description = _(
         b'long and reserved filenames may not work correctly; '
         b'repository performance is sub-optimal'
     )
 
     upgrademessage = _(
         b'repository will be more resilient to storing '
         b'certain paths and performance of certain '
         b'operations should be improved'
     )
 
 
 @registerformatvariant
 class dirstatev2(requirementformatvariant):
     name = b'dirstate-v2'
     _requirement = requirements.DIRSTATE_V2_REQUIREMENT
 
     default = False
 
     description = _(
         b'version 1 of the dirstate file format requires '
         b'reading and parsing it all at once.\n'
         b'Version 2 has a better structure,'
         b'better information and lighter update mechanism'
     )
 
     upgrademessage = _(b'"hg status" will be faster')
 
     touches_filelogs = False
     touches_manifests = False
     touches_changelog = False
     touches_requirements = True
     touches_dirstate = True
     compatible_with_share = True
 
 
 @registerformatvariant
 class dirstatetrackedkey(requirementformatvariant):
     name = b'tracked-hint'
     _requirement = requirements.DIRSTATE_TRACKED_HINT_V1
 
     default = False
 
     description = _(
         b'Add a small file to help external tooling that watch the tracked set'
     )
 
     upgrademessage = _(
         b'external tools will be informated of potential change in the tracked set'
     )
 
     touches_filelogs = False
     touches_manifests = False
     touches_changelog = False
     touches_requirements = True
     touches_dirstate = True
     compatible_with_share = True
 
 
 @registerformatvariant
 class dotencode(requirementformatvariant):
     name = b'dotencode'
 
     _requirement = requirements.DOTENCODE_REQUIREMENT
 
     default = True
 
     description = _(
         b'storage of filenames beginning with a period or '
         b'space may not work correctly'
     )
 
     upgrademessage = _(
         b'repository will be better able to store files '
         b'beginning with a space or period'
     )
 
 
 @registerformatvariant
 class generaldelta(requirementformatvariant):
     name = b'generaldelta'
 
     _requirement = requirements.GENERALDELTA_REQUIREMENT
 
     default = True
 
     description = _(
         b'deltas within internal storage are unable to '
         b'choose optimal revisions; repository is larger and '
         b'slower than it could be; interaction with other '
         b'repositories may require extra network and CPU '
         b'resources, making "hg push" and "hg pull" slower'
     )
 
     upgrademessage = _(
         b'repository storage will be able to create '
         b'optimal deltas; new repository data will be '
         b'smaller and read times should decrease; '
         b'interacting with other repositories using this '
         b'storage model should require less network and '
         b'CPU resources, making "hg push" and "hg pull" '
         b'faster'
     )
 
 
 @registerformatvariant
 class sharesafe(requirementformatvariant):
     name = b'share-safe'
     _requirement = requirements.SHARESAFE_REQUIREMENT
 
     default = True
 
     description = _(
         b'old shared repositories do not share source repository '
         b'requirements and config. This leads to various problems '
         b'when the source repository format is upgraded or some new '
         b'extensions are enabled.'
     )
 
     upgrademessage = _(
         b'Upgrades a repository to share-safe format so that future '
         b'shares of this repository share its requirements and configs.'
     )
 
     postdowngrademessage = _(
         b'repository downgraded to not use share safe mode, '
-        b'existing shares will not work and needs to'
-        b' be reshared.'
+        b'existing shares will not work and need to be reshared.'
     )
 
     postupgrademessage = _(
         b'repository upgraded to share safe mode, existing'
         b' shares will still work in old non-safe mode. '
         b'Re-share existing shares to use them in safe mode'
         b' New shares will be created in safe mode.'
     )
 
     # upgrade only needs to change the requirements
     touches_filelogs = False
     touches_manifests = False
     touches_changelog = False
     touches_requirements = True
 
 
 @registerformatvariant
 class sparserevlog(requirementformatvariant):
     name = b'sparserevlog'
 
     _requirement = requirements.SPARSEREVLOG_REQUIREMENT
 
     default = True
 
     description = _(
         b'in order to limit disk reading and memory usage on older '
         b'version, the span of a delta chain from its root to its '
         b'end is limited, whatever the relevant data in this span. '
         b'This can severly limit Mercurial ability to build good '
         b'chain of delta resulting is much more storage space being '
         b'taken and limit reusability of on disk delta during '
         b'exchange.'
     )
 
     upgrademessage = _(
         b'Revlog supports delta chain with more unused data '
         b'between payload. These gaps will be skipped at read '
         b'time. This allows for better delta chains, making a '
         b'better compression and faster exchange with server.'
     )
 
 
 @registerformatvariant
 class persistentnodemap(requirementformatvariant):
     name = b'persistent-nodemap'
 
     _requirement = requirements.NODEMAP_REQUIREMENT
 
     default = False
 
     description = _(
         b'persist the node -> rev mapping on disk to speedup lookup'
     )
 
     upgrademessage = _(b'Speedup revision lookup by node id.')
 
 
 @registerformatvariant
 class copiessdc(requirementformatvariant):
     name = b'copies-sdc'
 
     _requirement = requirements.COPIESSDC_REQUIREMENT
 
     default = False
 
     description = _(b'Stores copies information alongside changesets.')
 
     upgrademessage = _(
-        b'Allows to use more efficient algorithm to deal with ' b'copy tracing.'
+        b'Allows to use more efficient algorithm to deal with copy tracing.'
     )
 
     touches_filelogs = False
     touches_manifests = False
 
 
 @registerformatvariant
 class revlogv2(requirementformatvariant):
     name = b'revlog-v2'
     _requirement = requirements.REVLOGV2_REQUIREMENT
     default = False
     description = _(b'Version 2 of the revlog.')
     upgrademessage = _(b'very experimental')
 
 
 @registerformatvariant
 class changelogv2(requirementformatvariant):
     name = b'changelog-v2'
     _requirement = requirements.CHANGELOGV2_REQUIREMENT
     default = False
     description = _(b'An iteration of the revlog focussed on changelog needs.')
     upgrademessage = _(b'quite experimental')
 
     touches_filelogs = False
     touches_manifests = False
 
 
 @registerformatvariant
 class removecldeltachain(formatvariant):
     name = b'plain-cl-delta'
 
     default = True
 
     description = _(
         b'changelog storage is using deltas instead of '
         b'raw entries; changelog reading and any '
         b'operation relying on changelog data are slower '
         b'than they could be'
     )
 
     upgrademessage = _(
         b'changelog storage will be reformated to '
         b'store raw entries; changelog reading will be '
         b'faster; changelog size may be reduced'
     )
 
     @staticmethod
     def fromrepo(repo):
         # Mercurial 4.0 changed changelogs to not use delta chains. Search for
         # changelogs with deltas.
         cl = repo.changelog
         chainbase = cl.chainbase
         return all(rev == chainbase(rev) for rev in cl)
 
     @staticmethod
     def fromconfig(repo):
         return True
 
 
 _has_zstd = (
     b'zstd' in util.compengines
     and util.compengines[b'zstd'].available()
     and util.compengines[b'zstd'].revlogheader()
 )
 
 
 @registerformatvariant
 class compressionengine(formatvariant):
     name = b'compression'
 
     if _has_zstd:
         default = b'zstd'
     else:
         default = b'zlib'
 
     description = _(
         b'Compresion algorithm used to compress data. '
         b'Some engine are faster than other'
     )
 
     upgrademessage = _(
         b'revlog content will be recompressed with the new algorithm.'
     )
 
     @classmethod
     def fromrepo(cls, repo):
         # we allow multiple compression engine requirement to co-exist because
         # strickly speaking, revlog seems to support mixed compression style.
         #
         # The compression used for new entries will be "the last one"
         compression = b'zlib'
         for req in repo.requirements:
             prefix = req.startswith
             if prefix(b'revlog-compression-') or prefix(b'exp-compression-'):
                 compression = req.split(b'-', 2)[2]
         return compression
 
     @classmethod
     def fromconfig(cls, repo):
         compengines = repo.ui.configlist(b'format', b'revlog-compression')
         # return the first valid value as the selection code would do
         for comp in compengines:
             if comp in util.compengines:
                 e = util.compengines[comp]
                 if e.available() and e.revlogheader():
                     return comp
 
         # no valide compression found lets display it all for clarity
         return b','.join(compengines)
 
 
 @registerformatvariant
 class compressionlevel(formatvariant):
     name = b'compression-level'
     default = b'default'
 
     description = _(b'compression level')
 
     upgrademessage = _(b'revlog content will be recompressed')
 
     @classmethod
     def fromrepo(cls, repo):
         comp = compressionengine.fromrepo(repo)
         level = None
         if comp == b'zlib':
             level = repo.ui.configint(b'storage', b'revlog.zlib.level')
         elif comp == b'zstd':
             level = repo.ui.configint(b'storage', b'revlog.zstd.level')
         if level is None:
             return b'default'
         return bytes(level)
 
     @classmethod
     def fromconfig(cls, repo):
         comp = compressionengine.fromconfig(repo)
         level = None
         if comp == b'zlib':
             level = repo.ui.configint(b'storage', b'revlog.zlib.level')
         elif comp == b'zstd':
             level = repo.ui.configint(b'storage', b'revlog.zstd.level')
         if level is None:
             return b'default'
         return bytes(level)
 
 
 def find_format_upgrades(repo):
     """returns a list of format upgrades which can be perform on the repo"""
     upgrades = []
 
     # We could detect lack of revlogv1 and store here, but they were added
     # in 0.9.2 and we don't support upgrading repos without these
     # requirements, so let's not bother.
 
     for fv in allformatvariant:
         if not fv.fromrepo(repo):
             upgrades.append(fv)
 
     return upgrades
 
 
 def find_format_downgrades(repo):
     """returns a list of format downgrades which will be performed on the repo
     because of disabled config option for them"""
 
     downgrades = []
 
     for fv in allformatvariant:
         if fv.name == b'compression':
             # If there is a compression change between repository
             # and config, destination repository compression will change
             # and current compression will be removed.
             if fv.fromrepo(repo) != fv.fromconfig(repo):
                 downgrades.append(fv)
             continue
         # format variant exist in repo but does not exist in new repository
         # config
         if fv.fromrepo(repo) and not fv.fromconfig(repo):
             downgrades.append(fv)
 
     return downgrades
 
 
 ALL_OPTIMISATIONS = []
 
 
 def register_optimization(obj):
     ALL_OPTIMISATIONS.append(obj)
     return obj
 
 
 class optimization(improvement):
     """an improvement subclass dedicated to optimizations"""
 
     type = OPTIMISATION
 
 
 @register_optimization
 class redeltaparents(optimization):
     name = b're-delta-parent'
 
     type = OPTIMISATION
 
     description = _(
         b'deltas within internal storage will be recalculated to '
         b'choose an optimal base revision where this was not '
         b'already done; the size of the repository may shrink and '
         b'various operations may become faster; the first time '
         b'this optimization is performed could slow down upgrade '
         b'execution considerably; subsequent invocations should '
         b'not run noticeably slower'
     )
 
     upgrademessage = _(
         b'deltas within internal storage will choose a new '
         b'base revision if needed'
     )
 
 
 @register_optimization
 class redeltamultibase(optimization):
     name = b're-delta-multibase'
 
     type = OPTIMISATION
 
     description = _(
         b'deltas within internal storage will be recalculated '
         b'against multiple base revision and the smallest '
         b'difference will be used; the size of the repository may '
         b'shrink significantly when there are many merges; this '
         b'optimization will slow down execution in proportion to '
         b'the number of merges in the repository and the amount '
         b'of files in the repository; this slow down should not '
         b'be significant unless there are tens of thousands of '
         b'files and thousands of merges'
     )
 
     upgrademessage = _(
         b'deltas within internal storage will choose an '
         b'optimal delta by computing deltas against multiple '
         b'parents; may slow down execution time '
         b'significantly'
     )
 
 
 @register_optimization
 class redeltaall(optimization):
     name = b're-delta-all'
 
     type = OPTIMISATION
 
     description = _(
         b'deltas within internal storage will always be '
         b'recalculated without reusing prior deltas; this will '
         b'likely make execution run several times slower; this '
         b'optimization is typically not needed'
     )
 
     upgrademessage = _(
         b'deltas within internal storage will be fully '
         b'recomputed; this will likely drastically slow down '
         b'execution time'
     )
 
 
 @register_optimization
 class redeltafulladd(optimization):
     name = b're-delta-fulladd'
 
     type = OPTIMISATION
 
     description = _(
         b'every revision will be re-added as if it was new '
         b'content. It will go through the full storage '
         b'mechanism giving extensions a chance to process it '
         b'(eg. lfs). This is similar to "re-delta-all" but even '
         b'slower since more logic is involved.'
     )
 
     upgrademessage = _(
         b'each revision will be added as new content to the '
         b'internal storage; this will likely drastically slow '
         b'down execution time, but some extensions might need '
         b'it'
     )
 
 
 def findoptimizations(repo):
     """Determine optimisation that could be used during upgrade"""
     # These are unconditionally added. There is logic later that figures out
     # which ones to apply.
     return list(ALL_OPTIMISATIONS)
 
 
 def determine_upgrade_actions(
     repo, format_upgrades, optimizations, sourcereqs, destreqs
 ):
     """Determine upgrade actions that will be performed.
 
     Given a list of improvements as returned by ``find_format_upgrades`` and
     ``findoptimizations``, determine the list of upgrade actions that
     will be performed.
 
     The role of this function is to filter improvements if needed, apply
     recommended optimizations from the improvements list that make sense,
     etc.
 
     Returns a list of action names.
     """
     newactions = []
 
     for d in format_upgrades:
         if hasattr(d, '_requirement'):
             name = d._requirement
         else:
             name = None
 
         # If the action is a requirement that doesn't show up in the
         # destination requirements, prune the action.
         if name is not None and name not in destreqs:
             continue
 
         newactions.append(d)
 
     newactions.extend(
         o
         for o in sorted(optimizations, key=(lambda x: x.name))
         if o not in newactions
     )
 
     # FUTURE consider adding some optimizations here for certain transitions.
     # e.g. adding generaldelta could schedule parent redeltas.
 
     return newactions
 
 
 class BaseOperation:
     """base class that contains the minimum for an upgrade to work
 
     (this might need to be extended as the usage for subclass alternative to
     UpgradeOperation extends)
     """
 
     def __init__(
         self,
         new_requirements,
         backup_store,
     ):
         self.new_requirements = new_requirements
         # should this operation create a backup of the store
         self.backup_store = backup_store
 
 
 class UpgradeOperation(BaseOperation):
     """represent the work to be done during an upgrade"""
 
     def __init__(
         self,
         ui,
         new_requirements,
         current_requirements,
         upgrade_actions,
         removed_actions,
         revlogs_to_process,
         backup_store,
     ):
         super().__init__(
             new_requirements,
             backup_store,
         )
         self.ui = ui
         self.current_requirements = current_requirements
         # list of upgrade actions the operation will perform
         self.upgrade_actions = upgrade_actions
         self.removed_actions = removed_actions
         self.revlogs_to_process = revlogs_to_process
         # requirements which will be added by the operation
         self._added_requirements = (
             self.new_requirements - self.current_requirements
         )
         # requirements which will be removed by the operation
         self._removed_requirements = (
             self.current_requirements - self.new_requirements
         )
         # requirements which will be preserved by the operation
         self._preserved_requirements = (
             self.current_requirements & self.new_requirements
         )
         # optimizations which are not used and it's recommended that they
         # should use them
         all_optimizations = findoptimizations(None)
         self.unused_optimizations = [
             i for i in all_optimizations if i not in self.upgrade_actions
         ]
 
         # delta reuse mode of this upgrade operation
         upgrade_actions_names = self.upgrade_actions_names
         self.delta_reuse_mode = revlog.revlog.DELTAREUSEALWAYS
         if b're-delta-all' in upgrade_actions_names:
             self.delta_reuse_mode = revlog.revlog.DELTAREUSENEVER
         elif b're-delta-parent' in upgrade_actions_names:
             self.delta_reuse_mode = revlog.revlog.DELTAREUSESAMEREVS
         elif b're-delta-multibase' in upgrade_actions_names:
             self.delta_reuse_mode = revlog.revlog.DELTAREUSESAMEREVS
         elif b're-delta-fulladd' in upgrade_actions_names:
             self.delta_reuse_mode = revlog.revlog.DELTAREUSEFULLADD
 
         # should this operation force re-delta of both parents
         self.force_re_delta_both_parents = (
             b're-delta-multibase' in upgrade_actions_names
         )
 
     @property
     def upgrade_actions_names(self):
         return set([a.name for a in self.upgrade_actions])
 
     @property
     def requirements_only(self):
         # does the operation only touches repository requirement
         return (
             self.touches_requirements
             and not self.touches_filelogs
             and not self.touches_manifests
             and not self.touches_changelog
             and not self.touches_dirstate
         )
 
     @property
     def touches_filelogs(self):
         for a in self.upgrade_actions:
             # in optimisations, we re-process the revlogs again
             if a.type == OPTIMISATION:
                 return True
             elif a.touches_filelogs:
                 return True
         for a in self.removed_actions:
             if a.touches_filelogs:
                 return True
         return False
 
     @property
     def touches_manifests(self):
         for a in self.upgrade_actions:
             # in optimisations, we re-process the revlogs again
             if a.type == OPTIMISATION:
                 return True
             elif a.touches_manifests:
                 return True
         for a in self.removed_actions:
             if a.touches_manifests:
                 return True
         return False
 
     @property
     def touches_changelog(self):
         for a in self.upgrade_actions:
             # in optimisations, we re-process the revlogs again
             if a.type == OPTIMISATION:
                 return True
             elif a.touches_changelog:
                 return True
         for a in self.removed_actions:
             if a.touches_changelog:
                 return True
         return False
 
     @property
     def touches_requirements(self):
         for a in self.upgrade_actions:
             # optimisations are used to re-process revlogs and does not result
             # in a requirement being added or removed
             if a.type == OPTIMISATION:
                 pass
             elif a.touches_requirements:
                 return True
         for a in self.removed_actions:
             if a.touches_requirements:
                 return True
 
     @property
     def touches_dirstate(self):
         for a in self.upgrade_actions:
             # revlog optimisations do not affect the dirstate
             if a.type == OPTIMISATION:
                 pass
             elif a.touches_dirstate:
                 return True
         for a in self.removed_actions:
             if a.touches_dirstate:
                 return True
 
         return False
 
     def _write_labeled(self, l, label: bytes):
         """
         Utility function to aid writing of a list under one label
         """
         first = True
         for r in sorted(l):
             if not first:
                 self.ui.write(b', ')
             self.ui.write(r, label=label)
             first = False
 
     def print_requirements(self):
         self.ui.write(_(b'requirements\n'))
         self.ui.write(_(b'   preserved: '))
         self._write_labeled(
             self._preserved_requirements, b"upgrade-repo.requirement.preserved"
         )
         self.ui.write((b'\n'))
         if self._removed_requirements:
             self.ui.write(_(b'   removed: '))
             self._write_labeled(
                 self._removed_requirements, b"upgrade-repo.requirement.removed"
             )
             self.ui.write((b'\n'))
         if self._added_requirements:
             self.ui.write(_(b'   added: '))
             self._write_labeled(
                 self._added_requirements, b"upgrade-repo.requirement.added"
             )
             self.ui.write((b'\n'))
         self.ui.write(b'\n')
 
     def print_optimisations(self):
         optimisations = [
             a for a in self.upgrade_actions if a.type == OPTIMISATION
         ]
         optimisations.sort(key=lambda a: a.name)
         if optimisations:
             self.ui.write(_(b'optimisations: '))
             self._write_labeled(
                 [a.name for a in optimisations],
                 b"upgrade-repo.optimisation.performed",
             )
             self.ui.write(b'\n\n')
 
     def print_upgrade_actions(self):
         for a in self.upgrade_actions:
             self.ui.status(b'%s\n   %s\n\n' % (a.name, a.upgrademessage))
 
     def print_affected_revlogs(self):
         if not self.revlogs_to_process:
             self.ui.write((b'no revlogs to process\n'))
         else:
             self.ui.write((b'processed revlogs:\n'))
             for r in sorted(self.revlogs_to_process):
                 self.ui.write((b'  - %s\n' % r))
         self.ui.write((b'\n'))
 
     def print_unused_optimizations(self):
         for i in self.unused_optimizations:
             self.ui.status(_(b'%s\n   %s\n\n') % (i.name, i.description))
 
     def has_upgrade_action(self, name):
         """Check whether the upgrade operation will perform this action"""
         return name in self._upgrade_actions_names
 
     def print_post_op_messages(self):
         """print post upgrade operation warning messages"""
         for a in self.upgrade_actions:
             if a.postupgrademessage is not None:
                 self.ui.warn(b'%s\n' % a.postupgrademessage)
         for a in self.removed_actions:
             if a.postdowngrademessage is not None:
                 self.ui.warn(b'%s\n' % a.postdowngrademessage)
 
 
 ###  Code checking if a repository can got through the upgrade process at all. #
 
 
 def requiredsourcerequirements(repo):
     """Obtain requirements required to be present to upgrade a repo.
 
     An upgrade will not be allowed if the repository doesn't have the
     requirements returned by this function.
     """
     return {
         # Introduced in Mercurial 0.9.2.
         requirements.STORE_REQUIREMENT,
     }
 
 
 def blocksourcerequirements(repo):
     """Obtain requirements that will prevent an upgrade from occurring.
 
     An upgrade cannot be performed if the source repository contains a
     requirements in the returned set.
     """
     return {
         # This was a precursor to generaldelta and was never enabled by default.
         # It should (hopefully) not exist in the wild.
         b'parentdelta',
     }
 
 
 def check_revlog_version(reqs):
     """Check that the requirements contain at least one Revlog version"""
     all_revlogs = {
         requirements.REVLOGV1_REQUIREMENT,
         requirements.REVLOGV2_REQUIREMENT,
     }
     if not all_revlogs.intersection(reqs):
         msg = _(b'cannot upgrade repository; missing a revlog version')
         raise error.Abort(msg)
 
 
 def check_source_requirements(repo):
     """Ensure that no existing requirements prevent the repository upgrade"""
 
     check_revlog_version(repo.requirements)
     required = requiredsourcerequirements(repo)
     missingreqs = required - repo.requirements
     if missingreqs:
         msg = _(b'cannot upgrade repository; requirement missing: %s')
         missingreqs = b', '.join(sorted(missingreqs))
         raise error.Abort(msg % missingreqs)
 
     blocking = blocksourcerequirements(repo)
     blockingreqs = blocking & repo.requirements
     if blockingreqs:
         m = _(b'cannot upgrade repository; unsupported source requirement: %s')
         blockingreqs = b', '.join(sorted(blockingreqs))
         raise error.Abort(m % blockingreqs)
     # Upgrade should operate on the actual store, not the shared link.
 
     bad_share = (
         requirements.SHARED_REQUIREMENT in repo.requirements
         and requirements.SHARESAFE_REQUIREMENT not in repo.requirements
     )
     if bad_share:
         m = _(b'cannot upgrade repository; share repository without share-safe')
         h = _(b'check :hg:`help config.format.use-share-safe`')
         raise error.Abort(m, hint=h)
 
 
 ### Verify the validity of the planned requirement changes ####################
 
 
 def supportremovedrequirements(repo):
     """Obtain requirements that can be removed during an upgrade.
 
     If an upgrade were to create a repository that dropped a requirement,
     the dropped requirement must appear in the returned set for the upgrade
     to be allowed.
     """
     supported = {
         requirements.SPARSEREVLOG_REQUIREMENT,
         requirements.COPIESSDC_REQUIREMENT,
         requirements.NODEMAP_REQUIREMENT,
         requirements.SHARESAFE_REQUIREMENT,
         requirements.REVLOGV2_REQUIREMENT,
         requirements.CHANGELOGV2_REQUIREMENT,
         requirements.REVLOGV1_REQUIREMENT,
         requirements.DIRSTATE_TRACKED_HINT_V1,
         requirements.DIRSTATE_V2_REQUIREMENT,
     }
     for name in compression.compengines:
         engine = compression.compengines[name]
         if engine.available() and engine.revlogheader():
             supported.add(b'exp-compression-%s' % name)
             if engine.name() == b'zstd':
                 supported.add(b'revlog-compression-zstd')
     return supported
 
 
 def supporteddestrequirements(repo):
     """Obtain requirements that upgrade supports in the destination.
 
     If the result of the upgrade would have requirements not in this set,
     the upgrade is disallowed.
 
     Extensions should monkeypatch this to add their custom requirements.
     """
     supported = {
         requirements.CHANGELOGV2_REQUIREMENT,
         requirements.COPIESSDC_REQUIREMENT,
         requirements.DIRSTATE_TRACKED_HINT_V1,
         requirements.DIRSTATE_V2_REQUIREMENT,
         requirements.DOTENCODE_REQUIREMENT,
         requirements.FNCACHE_REQUIREMENT,
         requirements.GENERALDELTA_REQUIREMENT,
         requirements.NODEMAP_REQUIREMENT,
         requirements.REVLOGV1_REQUIREMENT,  # allowed in case of downgrade
         requirements.REVLOGV2_REQUIREMENT,
         requirements.SHARED_REQUIREMENT,
         requirements.SHARESAFE_REQUIREMENT,
         requirements.SPARSEREVLOG_REQUIREMENT,
         requirements.STORE_REQUIREMENT,
         requirements.TREEMANIFEST_REQUIREMENT,
         requirements.NARROW_REQUIREMENT,
     }
     for name in compression.compengines:
         engine = compression.compengines[name]
         if engine.available() and engine.revlogheader():
             supported.add(b'exp-compression-%s' % name)
             if engine.name() == b'zstd':
                 supported.add(b'revlog-compression-zstd')
     return supported
 
 
 def allowednewrequirements(repo):
     """Obtain requirements that can be added to a repository during upgrade.
 
     This is used to disallow proposed requirements from being added when
     they weren't present before.
 
     We use a list of allowed requirement additions instead of a list of known
     bad additions because the whitelist approach is safer and will prevent
     future, unknown requirements from accidentally being added.
     """
     supported = {
         requirements.DOTENCODE_REQUIREMENT,
         requirements.FNCACHE_REQUIREMENT,
         requirements.GENERALDELTA_REQUIREMENT,
         requirements.SPARSEREVLOG_REQUIREMENT,
         requirements.COPIESSDC_REQUIREMENT,
         requirements.NODEMAP_REQUIREMENT,
         requirements.SHARESAFE_REQUIREMENT,
         requirements.REVLOGV1_REQUIREMENT,
         requirements.REVLOGV2_REQUIREMENT,
         requirements.CHANGELOGV2_REQUIREMENT,
         requirements.DIRSTATE_TRACKED_HINT_V1,
         requirements.DIRSTATE_V2_REQUIREMENT,
     }
     for name in compression.compengines:
         engine = compression.compengines[name]
         if engine.available() and engine.revlogheader():
             supported.add(b'exp-compression-%s' % name)
             if engine.name() == b'zstd':
                 supported.add(b'revlog-compression-zstd')
     return supported
 
 
 def check_requirements_changes(repo, new_reqs):
     old_reqs = repo.requirements
     check_revlog_version(repo.requirements)
     support_removal = supportremovedrequirements(repo)
     no_remove_reqs = old_reqs - new_reqs - support_removal
     if no_remove_reqs:
         msg = _(b'cannot upgrade repository; requirement would be removed: %s')
         no_remove_reqs = b', '.join(sorted(no_remove_reqs))
         raise error.Abort(msg % no_remove_reqs)
 
     support_addition = allowednewrequirements(repo)
     no_add_reqs = new_reqs - old_reqs - support_addition
     if no_add_reqs:
         m = _(b'cannot upgrade repository; do not support adding requirement: ')
         no_add_reqs = b', '.join(sorted(no_add_reqs))
         raise error.Abort(m + no_add_reqs)
 
     supported = supporteddestrequirements(repo)
     unsupported_reqs = new_reqs - supported
     if unsupported_reqs:
         msg = _(
             b'cannot upgrade repository; do not support destination '
             b'requirement: %s'
         )
         unsupported_reqs = b', '.join(sorted(unsupported_reqs))
         raise error.Abort(msg % unsupported_reqs)

rust/hg-core/src/revlog/mod.rs

@@ -1,951 +1,965 b''
 // Copyright 2018-2023 Georges Racinet <[e-mail]>
 //           and Mercurial contributors
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 //! Mercurial concepts for handling revision history
 
 pub mod node;
 pub mod nodemap;
 mod nodemap_docket;
 pub mod path_encode;
 pub use node::{FromHexError, Node, NodePrefix};
 pub mod changelog;
 pub mod filelog;
 pub mod index;
 pub mod manifest;
 pub mod patch;
 
 use std::borrow::Cow;
 use std::io::Read;
 use std::ops::Deref;
 use std::path::Path;
 
 use flate2::read::ZlibDecoder;
 use sha1::{Digest, Sha1};
 use std::cell::RefCell;
 use zstd;
 
 use self::node::{NODE_BYTES_LENGTH, NULL_NODE};
 use self::nodemap_docket::NodeMapDocket;
 use super::index::Index;
 use super::nodemap::{NodeMap, NodeMapError};
 use crate::errors::HgError;
 use crate::vfs::Vfs;
 
 /// As noted in revlog.c, revision numbers are actually encoded in
 /// 4 bytes, and are liberally converted to ints, whence the i32
 pub type BaseRevision = i32;
 
 /// Mercurial revision numbers
 /// In contrast to the more general [`UncheckedRevision`], these are "checked"
 /// in the sense that they should only be used for revisions that are
 /// valid for a given index (i.e. in bounds).
 #[derive(
     Debug,
     derive_more::Display,
     Clone,
     Copy,
     Hash,
     PartialEq,
     Eq,
     PartialOrd,
     Ord,
 )]
 pub struct Revision(pub BaseRevision);
 
 impl format_bytes::DisplayBytes for Revision {
     fn display_bytes(
         &self,
         output: &mut dyn std::io::Write,
     ) -> std::io::Result<()> {
         self.0.display_bytes(output)
     }
 }
 
 /// Unchecked Mercurial revision numbers.
 ///
 /// Values of this type have no guarantee of being a valid revision number
 /// in any context. Use method `check_revision` to get a valid revision within
 /// the appropriate index object.
 #[derive(
     Debug,
     derive_more::Display,
     Clone,
     Copy,
     Hash,
     PartialEq,
     Eq,
     PartialOrd,
     Ord,
 )]
 pub struct UncheckedRevision(pub BaseRevision);
 
 impl format_bytes::DisplayBytes for UncheckedRevision {
     fn display_bytes(
         &self,
         output: &mut dyn std::io::Write,
     ) -> std::io::Result<()> {
         self.0.display_bytes(output)
     }
 }
 
 impl From<Revision> for UncheckedRevision {
     fn from(value: Revision) -> Self {
         Self(value.0)
     }
 }
 
 impl From<BaseRevision> for UncheckedRevision {
     fn from(value: BaseRevision) -> Self {
         Self(value)
     }
 }
 
 /// Marker expressing the absence of a parent
 ///
 /// Independently of the actual representation, `NULL_REVISION` is guaranteed
 /// to be smaller than all existing revisions.
 pub const NULL_REVISION: Revision = Revision(-1);
 
 /// Same as `mercurial.node.wdirrev`
 ///
 /// This is also equal to `i32::max_value()`, but it's better to spell
 /// it out explicitely, same as in `mercurial.node`
 #[allow(clippy::unreadable_literal)]
 pub const WORKING_DIRECTORY_REVISION: UncheckedRevision =
     UncheckedRevision(0x7fffffff);
 
 pub const WORKING_DIRECTORY_HEX: &str =
     "ffffffffffffffffffffffffffffffffffffffff";
 
 /// The simplest expression of what we need of Mercurial DAGs.
 pub trait Graph {
     /// Return the two parents of the given `Revision`.
     ///
     /// Each of the parents can be independently `NULL_REVISION`
     fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError>;
 }
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum GraphError {
     ParentOutOfRange(Revision),
 }
 
 /// The Mercurial Revlog Index
 ///
 /// This is currently limited to the minimal interface that is needed for
 /// the [`nodemap`](nodemap/index.html) module
 pub trait RevlogIndex {
     /// Total number of Revisions referenced in this index
     fn len(&self) -> usize;
 
     fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
     /// Return a reference to the Node or `None` for `NULL_REVISION`
     fn node(&self, rev: Revision) -> Option<&Node>;
 
     /// Return a [`Revision`] if `rev` is a valid revision number for this
     /// index
     fn check_revision(&self, rev: UncheckedRevision) -> Option<Revision> {
         let rev = rev.0;
 
         if rev == NULL_REVISION.0 || (rev >= 0 && (rev as usize) < self.len())
         {
             Some(Revision(rev))
         } else {
             None
         }
     }
 }
 
 const REVISION_FLAG_CENSORED: u16 = 1 << 15;
 const REVISION_FLAG_ELLIPSIS: u16 = 1 << 14;
 const REVISION_FLAG_EXTSTORED: u16 = 1 << 13;
 const REVISION_FLAG_HASCOPIESINFO: u16 = 1 << 12;
 
 // Keep this in sync with REVIDX_KNOWN_FLAGS in
 // mercurial/revlogutils/flagutil.py
 const REVIDX_KNOWN_FLAGS: u16 = REVISION_FLAG_CENSORED
     | REVISION_FLAG_ELLIPSIS
     | REVISION_FLAG_EXTSTORED
     | REVISION_FLAG_HASCOPIESINFO;
 
 const NULL_REVLOG_ENTRY_FLAGS: u16 = 0;
 
 #[derive(Debug, derive_more::From, derive_more::Display)]
 pub enum RevlogError {
     InvalidRevision,
     /// Working directory is not supported
     WDirUnsupported,
     /// Found more than one entry whose ID match the requested prefix
     AmbiguousPrefix,
     #[from]
     Other(HgError),
 }
 
 impl From<NodeMapError> for RevlogError {
     fn from(error: NodeMapError) -> Self {
         match error {
             NodeMapError::MultipleResults => RevlogError::AmbiguousPrefix,
             NodeMapError::RevisionNotInIndex(rev) => RevlogError::corrupted(
                 format!("nodemap point to revision {} not in index", rev),
             ),
         }
     }
 }
 
 fn corrupted<S: AsRef<str>>(context: S) -> HgError {
     HgError::corrupted(format!("corrupted revlog, {}", context.as_ref()))
 }
 
 impl RevlogError {
     fn corrupted<S: AsRef<str>>(context: S) -> Self {
         RevlogError::Other(corrupted(context))
     }
 }
 
 /// Read only implementation of revlog.
 pub struct Revlog {
     /// When index and data are not interleaved: bytes of the revlog index.
     /// When index and data are interleaved: bytes of the revlog index and
     /// data.
     index: Index,
     /// When index and data are not interleaved: bytes of the revlog data
     data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>>,
     /// When present on disk: the persistent nodemap for this revlog
     nodemap: Option<nodemap::NodeTree>,
 }
 
 impl Graph for Revlog {
     fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError> {
         self.index.parents(rev)
     }
 }
 
 impl Revlog {
     /// Open a revlog index file.
     ///
     /// It will also open the associated data file if index and data are not
     /// interleaved.
     pub fn open(
         store_vfs: &Vfs,
         index_path: impl AsRef<Path>,
         data_path: Option<&Path>,
         use_nodemap: bool,
     ) -> Result<Self, HgError> {
+        Self::open_gen(store_vfs, index_path, data_path, use_nodemap, None)
+    }
+
+    fn open_gen(
+        store_vfs: &Vfs,
+        index_path: impl AsRef<Path>,
+        data_path: Option<&Path>,
+        use_nodemap: bool,
+        nodemap_for_test: Option<nodemap::NodeTree>,
+    ) -> Result<Self, HgError> {
         let index_path = index_path.as_ref();
         let index = {
             match store_vfs.mmap_open_opt(&index_path)? {
                 None => Index::new(Box::new(vec![])),
                 Some(index_mmap) => {
                     let index = Index::new(Box::new(index_mmap))?;
                     Ok(index)
                 }
             }
         }?;
 
         let default_data_path = index_path.with_extension("d");
 
         // type annotation required
         // won't recognize Mmap as Deref<Target = [u8]>
         let data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>> =
             if index.is_inline() {
                 None
             } else {
                 let data_path = data_path.unwrap_or(&default_data_path);
                 let data_mmap = store_vfs.mmap_open(data_path)?;
                 Some(Box::new(data_mmap))
             };
 
         let nodemap = if index.is_inline() || !use_nodemap {
             None
         } else {
             NodeMapDocket::read_from_file(store_vfs, index_path)?.map(
                 |(docket, data)| {
                     nodemap::NodeTree::load_bytes(
                         Box::new(data),
                         docket.data_length,
                     )
                 },
             )
         };
 
+        let nodemap = nodemap_for_test.or(nodemap);
+
         Ok(Revlog {
             index,
             data_bytes,
             nodemap,
         })
     }
 
     /// Return number of entries of the `Revlog`.
     pub fn len(&self) -> usize {
         self.index.len()
     }
 
     /// Returns `true` if the `Revlog` has zero `entries`.
     pub fn is_empty(&self) -> bool {
         self.index.is_empty()
     }
 
     /// Returns the node ID for the given revision number, if it exists in this
     /// revlog
     pub fn node_from_rev(&self, rev: UncheckedRevision) -> Option<&Node> {
         if rev == NULL_REVISION.into() {
             return Some(&NULL_NODE);
         }
         let rev = self.index.check_revision(rev)?;
         Some(self.index.get_entry(rev)?.hash())
     }
 
     /// Return the revision number for the given node ID, if it exists in this
     /// revlog
     pub fn rev_from_node(
         &self,
         node: NodePrefix,
     ) -> Result<Revision, RevlogError> {
-        let looked_up = if let Some(nodemap) = &self.nodemap {
+        if let Some(nodemap) = &self.nodemap {
             nodemap
                 .find_bin(&self.index, node)?
                 .ok_or(RevlogError::InvalidRevision)
         } else {
             self.rev_from_node_no_persistent_nodemap(node)
-        };
-
-        if node.is_prefix_of(&NULL_NODE) {
-            return match looked_up {
-                Ok(_) => Err(RevlogError::AmbiguousPrefix),
-                Err(RevlogError::InvalidRevision) => Ok(NULL_REVISION),
-                res => res,
-            };
-        };
-
-        looked_up
+        }
     }
 
     /// Same as `rev_from_node`, without using a persistent nodemap
     ///
     /// This is used as fallback when a persistent nodemap is not present.
     /// This happens when the persistent-nodemap experimental feature is not
     /// enabled, or for small revlogs.
     fn rev_from_node_no_persistent_nodemap(
         &self,
         node: NodePrefix,
     ) -> Result<Revision, RevlogError> {
         // Linear scan of the revlog
         // TODO: consider building a non-persistent nodemap in memory to
         // optimize these cases.
         let mut found_by_prefix = None;
-        for rev in (0..self.len()).rev() {
+        for rev in (-1..self.len() as BaseRevision).rev() {
             let rev = Revision(rev as BaseRevision);
-            let index_entry = self.index.get_entry(rev).ok_or_else(|| {
-                HgError::corrupted(
-                    "revlog references a revision not in the index",
-                )
-            })?;
-            if node == *index_entry.hash() {
+            let candidate_node = if rev == Revision(-1) {
+                NULL_NODE
+            } else {
+                let index_entry =
+                    self.index.get_entry(rev).ok_or_else(|| {
+                        HgError::corrupted(
+                            "revlog references a revision not in the index",
+                        )
+                    })?;
+                *index_entry.hash()
+            };
+            if node == candidate_node {
                 return Ok(rev);
             }
-            if node.is_prefix_of(index_entry.hash()) {
+            if node.is_prefix_of(&candidate_node) {
                 if found_by_prefix.is_some() {
                     return Err(RevlogError::AmbiguousPrefix);
                 }
                 found_by_prefix = Some(rev)
             }
         }
         found_by_prefix.ok_or(RevlogError::InvalidRevision)
     }
 
     /// Returns whether the given revision exists in this revlog.
     pub fn has_rev(&self, rev: UncheckedRevision) -> bool {
         self.index.check_revision(rev).is_some()
     }
 
     /// Return the full data associated to a revision.
     ///
     /// All entries required to build the final data out of deltas will be
     /// retrieved as needed, and the deltas will be applied to the inital
     /// snapshot to rebuild the final data.
     pub fn get_rev_data(
         &self,
         rev: UncheckedRevision,
     ) -> Result<Cow<[u8]>, RevlogError> {
         if rev == NULL_REVISION.into() {
             return Ok(Cow::Borrowed(&[]));
         };
         self.get_entry(rev)?.data()
     }
 
     /// [`Self::get_rev_data`] for checked revisions.
     pub fn get_rev_data_for_checked_rev(
         &self,
         rev: Revision,
     ) -> Result<Cow<[u8]>, RevlogError> {
         if rev == NULL_REVISION {
             return Ok(Cow::Borrowed(&[]));
         };
         self.get_entry_for_checked_rev(rev)?.data()
     }
 
     /// Check the hash of some given data against the recorded hash.
     pub fn check_hash(
         &self,
         p1: Revision,
         p2: Revision,
         expected: &[u8],
         data: &[u8],
     ) -> bool {
         let e1 = self.index.get_entry(p1);
         let h1 = match e1 {
             Some(ref entry) => entry.hash(),
             None => &NULL_NODE,
         };
         let e2 = self.index.get_entry(p2);
         let h2 = match e2 {
             Some(ref entry) => entry.hash(),
             None => &NULL_NODE,
         };
 
         hash(data, h1.as_bytes(), h2.as_bytes()) == expected
     }
 
     /// Build the full data of a revision out its snapshot
     /// and its deltas.
     fn build_data_from_deltas(
         snapshot: RevlogEntry,
         deltas: &[RevlogEntry],
     ) -> Result<Vec<u8>, HgError> {
         let snapshot = snapshot.data_chunk()?;
         let deltas = deltas
             .iter()
             .rev()
             .map(RevlogEntry::data_chunk)
             .collect::<Result<Vec<_>, _>>()?;
         let patches: Vec<_> =
             deltas.iter().map(|d| patch::PatchList::new(d)).collect();
         let patch = patch::fold_patch_lists(&patches);
         Ok(patch.apply(&snapshot))
     }
 
     /// Return the revlog data.
     fn data(&self) -> &[u8] {
         match &self.data_bytes {
             Some(data_bytes) => data_bytes,
             None => panic!(
                 "forgot to load the data or trying to access inline data"
             ),
         }
     }
 
     pub fn make_null_entry(&self) -> RevlogEntry {
         RevlogEntry {
             revlog: self,
             rev: NULL_REVISION,
             bytes: b"",
             compressed_len: 0,
             uncompressed_len: 0,
             base_rev_or_base_of_delta_chain: None,
             p1: NULL_REVISION,
             p2: NULL_REVISION,
             flags: NULL_REVLOG_ENTRY_FLAGS,
             hash: NULL_NODE,
         }
     }
 
     fn get_entry_for_checked_rev(
         &self,
         rev: Revision,
     ) -> Result<RevlogEntry, RevlogError> {
         if rev == NULL_REVISION {
             return Ok(self.make_null_entry());
         }
         let index_entry = self
             .index
             .get_entry(rev)
             .ok_or(RevlogError::InvalidRevision)?;
         let start = index_entry.offset();
         let end = start + index_entry.compressed_len() as usize;
         let data = if self.index.is_inline() {
             self.index.data(start, end)
         } else {
             &self.data()[start..end]
         };
         let base_rev = self
             .index
             .check_revision(index_entry.base_revision_or_base_of_delta_chain())
             .ok_or_else(|| {
                 RevlogError::corrupted(format!(
                     "base revision for rev {} is invalid",
                     rev
                 ))
             })?;
         let p1 =
             self.index.check_revision(index_entry.p1()).ok_or_else(|| {
                 RevlogError::corrupted(format!(
                     "p1 for rev {} is invalid",
                     rev
                 ))
             })?;
         let p2 =
             self.index.check_revision(index_entry.p2()).ok_or_else(|| {
                 RevlogError::corrupted(format!(
                     "p2 for rev {} is invalid",
                     rev
                 ))
             })?;
         let entry = RevlogEntry {
             revlog: self,
             rev,
             bytes: data,
             compressed_len: index_entry.compressed_len(),
             uncompressed_len: index_entry.uncompressed_len(),
             base_rev_or_base_of_delta_chain: if base_rev == rev {
                 None
             } else {
                 Some(base_rev)
             },
             p1,
             p2,
             flags: index_entry.flags(),
             hash: *index_entry.hash(),
         };
         Ok(entry)
     }
 
     /// Get an entry of the revlog.
     pub fn get_entry(
         &self,
         rev: UncheckedRevision,
     ) -> Result<RevlogEntry, RevlogError> {
         if rev == NULL_REVISION.into() {
             return Ok(self.make_null_entry());
         }
         let rev = self.index.check_revision(rev).ok_or_else(|| {
             RevlogError::corrupted(format!("rev {} is invalid", rev))
         })?;
         self.get_entry_for_checked_rev(rev)
     }
 }
 
 /// The revlog entry's bytes and the necessary informations to extract
 /// the entry's data.
 #[derive(Clone)]
 pub struct RevlogEntry<'revlog> {
     revlog: &'revlog Revlog,
     rev: Revision,
     bytes: &'revlog [u8],
     compressed_len: u32,
     uncompressed_len: i32,
     base_rev_or_base_of_delta_chain: Option<Revision>,
     p1: Revision,
     p2: Revision,
     flags: u16,
     hash: Node,
 }
 
 thread_local! {
   // seems fine to [unwrap] here: this can only fail due to memory allocation
   // failing, and it's normal for that to cause panic.
   static ZSTD_DECODER : RefCell<zstd::bulk::Decompressor<'static>> =
       RefCell::new(zstd::bulk::Decompressor::new().ok().unwrap());
 }
 
 fn zstd_decompress_to_buffer(
     bytes: &[u8],
     buf: &mut Vec<u8>,
 ) -> Result<usize, std::io::Error> {
     ZSTD_DECODER
         .with(|decoder| decoder.borrow_mut().decompress_to_buffer(bytes, buf))
 }
 
 impl<'revlog> RevlogEntry<'revlog> {
     pub fn revision(&self) -> Revision {
         self.rev
     }
 
     pub fn node(&self) -> &Node {
         &self.hash
     }
 
     pub fn uncompressed_len(&self) -> Option<u32> {
         u32::try_from(self.uncompressed_len).ok()
     }
 
     pub fn has_p1(&self) -> bool {
         self.p1 != NULL_REVISION
     }
 
     pub fn p1_entry(
         &self,
     ) -> Result<Option<RevlogEntry<'revlog>>, RevlogError> {
         if self.p1 == NULL_REVISION {
             Ok(None)
         } else {
             Ok(Some(self.revlog.get_entry_for_checked_rev(self.p1)?))
         }
     }
 
     pub fn p2_entry(
         &self,
     ) -> Result<Option<RevlogEntry<'revlog>>, RevlogError> {
         if self.p2 == NULL_REVISION {
             Ok(None)
         } else {
             Ok(Some(self.revlog.get_entry_for_checked_rev(self.p2)?))
         }
     }
 
     pub fn p1(&self) -> Option<Revision> {
         if self.p1 == NULL_REVISION {
             None
         } else {
             Some(self.p1)
         }
     }
 
     pub fn p2(&self) -> Option<Revision> {
         if self.p2 == NULL_REVISION {
             None
         } else {
             Some(self.p2)
         }
     }
 
     pub fn is_censored(&self) -> bool {
         (self.flags & REVISION_FLAG_CENSORED) != 0
     }
 
     pub fn has_length_affecting_flag_processor(&self) -> bool {
         // Relevant Python code: revlog.size()
         // note: ELLIPSIS is known to not change the content
         (self.flags & (REVIDX_KNOWN_FLAGS ^ REVISION_FLAG_ELLIPSIS)) != 0
     }
 
     /// The data for this entry, after resolving deltas if any.
     pub fn rawdata(&self) -> Result<Cow<'revlog, [u8]>, RevlogError> {
         let mut entry = self.clone();
         let mut delta_chain = vec![];
 
         // The meaning of `base_rev_or_base_of_delta_chain` depends on
         // generaldelta. See the doc on `ENTRY_DELTA_BASE` in
         // `mercurial/revlogutils/constants.py` and the code in
         // [_chaininfo] and in [index_deltachain].
         let uses_generaldelta = self.revlog.index.uses_generaldelta();
         while let Some(base_rev) = entry.base_rev_or_base_of_delta_chain {
             entry = if uses_generaldelta {
                 delta_chain.push(entry);
                 self.revlog.get_entry_for_checked_rev(base_rev)?
             } else {
                 let base_rev = UncheckedRevision(entry.rev.0 - 1);
                 delta_chain.push(entry);
                 self.revlog.get_entry(base_rev)?
             };
         }
 
         let data = if delta_chain.is_empty() {
             entry.data_chunk()?
         } else {
             Revlog::build_data_from_deltas(entry, &delta_chain)?.into()
         };
 
         Ok(data)
     }
 
     fn check_data(
         &self,
         data: Cow<'revlog, [u8]>,
     ) -> Result<Cow<'revlog, [u8]>, RevlogError> {
         if self.revlog.check_hash(
             self.p1,
             self.p2,
             self.hash.as_bytes(),
             &data,
         ) {
             Ok(data)
         } else {
             if (self.flags & REVISION_FLAG_ELLIPSIS) != 0 {
                 return Err(HgError::unsupported(
                     "ellipsis revisions are not supported by rhg",
                 )
                 .into());
             }
             Err(corrupted(format!(
                 "hash check failed for revision {}",
                 self.rev
             ))
             .into())
         }
     }
 
     pub fn data(&self) -> Result<Cow<'revlog, [u8]>, RevlogError> {
         let data = self.rawdata()?;
         if self.rev == NULL_REVISION {
             return Ok(data);
         }
         if self.is_censored() {
             return Err(HgError::CensoredNodeError.into());
         }
         self.check_data(data)
     }
 
     /// Extract the data contained in the entry.
     /// This may be a delta. (See `is_delta`.)
     fn data_chunk(&self) -> Result<Cow<'revlog, [u8]>, HgError> {
         if self.bytes.is_empty() {
             return Ok(Cow::Borrowed(&[]));
         }
         match self.bytes[0] {
             // Revision data is the entirety of the entry, including this
             // header.
             b'\0' => Ok(Cow::Borrowed(self.bytes)),
             // Raw revision data follows.
             b'u' => Ok(Cow::Borrowed(&self.bytes[1..])),
             // zlib (RFC 1950) data.
             b'x' => Ok(Cow::Owned(self.uncompressed_zlib_data()?)),
             // zstd data.
             b'\x28' => Ok(Cow::Owned(self.uncompressed_zstd_data()?)),
             // A proper new format should have had a repo/store requirement.
             format_type => Err(corrupted(format!(
                 "unknown compression header '{}'",
                 format_type
             ))),
         }
     }
 
     fn uncompressed_zlib_data(&self) -> Result<Vec<u8>, HgError> {
         let mut decoder = ZlibDecoder::new(self.bytes);
         if self.is_delta() {
             let mut buf = Vec::with_capacity(self.compressed_len as usize);
             decoder
                 .read_to_end(&mut buf)
                 .map_err(|e| corrupted(e.to_string()))?;
             Ok(buf)
         } else {
             let cap = self.uncompressed_len.max(0) as usize;
             let mut buf = vec![0; cap];
             decoder
                 .read_exact(&mut buf)
                 .map_err(|e| corrupted(e.to_string()))?;
             Ok(buf)
         }
     }
 
     fn uncompressed_zstd_data(&self) -> Result<Vec<u8>, HgError> {
         let cap = self.uncompressed_len.max(0) as usize;
         if self.is_delta() {
             // [cap] is usually an over-estimate of the space needed because
             // it's the length of delta-decoded data, but we're interested
             // in the size of the delta.
             // This means we have to [shrink_to_fit] to avoid holding on
             // to a large chunk of memory, but it also means we must have a
             // fallback branch, for the case when the delta is longer than
             // the original data (surprisingly, this does happen in practice)
             let mut buf = Vec::with_capacity(cap);
             match zstd_decompress_to_buffer(self.bytes, &mut buf) {
                 Ok(_) => buf.shrink_to_fit(),
                 Err(_) => {
                     buf.clear();
                     zstd::stream::copy_decode(self.bytes, &mut buf)
                         .map_err(|e| corrupted(e.to_string()))?;
                 }
             };
             Ok(buf)
         } else {
             let mut buf = Vec::with_capacity(cap);
             let len = zstd_decompress_to_buffer(self.bytes, &mut buf)
                 .map_err(|e| corrupted(e.to_string()))?;
             if len != self.uncompressed_len as usize {
                 Err(corrupted("uncompressed length does not match"))
             } else {
                 Ok(buf)
             }
         }
     }
 
     /// Tell if the entry is a snapshot or a delta
     /// (influences on decompression).
     fn is_delta(&self) -> bool {
         self.base_rev_or_base_of_delta_chain.is_some()
     }
 }
 
 /// Calculate the hash of a revision given its data and its parents.
 fn hash(
     data: &[u8],
     p1_hash: &[u8],
     p2_hash: &[u8],
 ) -> [u8; NODE_BYTES_LENGTH] {
     let mut hasher = Sha1::new();
     let (a, b) = (p1_hash, p2_hash);
     if a > b {
         hasher.update(b);
         hasher.update(a);
     } else {
         hasher.update(a);
         hasher.update(b);
     }
     hasher.update(data);
     *hasher.finalize().as_ref()
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::index::{IndexEntryBuilder, INDEX_ENTRY_SIZE};
     use itertools::Itertools;
 
     #[test]
     fn test_empty() {
         let temp = tempfile::tempdir().unwrap();
         let vfs = Vfs { base: temp.path() };
         std::fs::write(temp.path().join("foo.i"), b"").unwrap();
         let revlog = Revlog::open(&vfs, "foo.i", None, false).unwrap();
         assert!(revlog.is_empty());
         assert_eq!(revlog.len(), 0);
         assert!(revlog.get_entry(0.into()).is_err());
         assert!(!revlog.has_rev(0.into()));
         assert_eq!(
             revlog.rev_from_node(NULL_NODE.into()).unwrap(),
             NULL_REVISION
         );
         let null_entry = revlog.get_entry(NULL_REVISION.into()).ok().unwrap();
         assert_eq!(null_entry.revision(), NULL_REVISION);
         assert!(null_entry.data().unwrap().is_empty());
     }
 
     #[test]
     fn test_inline() {
         let temp = tempfile::tempdir().unwrap();
         let vfs = Vfs { base: temp.path() };
         let node0 = Node::from_hex("2ed2a3912a0b24502043eae84ee4b279c18b90dd")
             .unwrap();
         let node1 = Node::from_hex("b004912a8510032a0350a74daa2803dadfb00e12")
             .unwrap();
         let node2 = Node::from_hex("dd6ad206e907be60927b5a3117b97dffb2590582")
             .unwrap();
         let entry0_bytes = IndexEntryBuilder::new()
             .is_first(true)
             .with_version(1)
             .with_inline(true)
             .with_offset(INDEX_ENTRY_SIZE)
             .with_node(node0)
             .build();
         let entry1_bytes = IndexEntryBuilder::new()
             .with_offset(INDEX_ENTRY_SIZE)
             .with_node(node1)
             .build();
         let entry2_bytes = IndexEntryBuilder::new()
             .with_offset(INDEX_ENTRY_SIZE)
             .with_p1(Revision(0))
             .with_p2(Revision(1))
             .with_node(node2)
             .build();
         let contents = vec![entry0_bytes, entry1_bytes, entry2_bytes]
             .into_iter()
             .flatten()
             .collect_vec();
         std::fs::write(temp.path().join("foo.i"), contents).unwrap();
         let revlog = Revlog::open(&vfs, "foo.i", None, false).unwrap();
 
         let entry0 = revlog.get_entry(0.into()).ok().unwrap();
         assert_eq!(entry0.revision(), Revision(0));
         assert_eq!(*entry0.node(), node0);
         assert!(!entry0.has_p1());
         assert_eq!(entry0.p1(), None);
         assert_eq!(entry0.p2(), None);
         let p1_entry = entry0.p1_entry().unwrap();
         assert!(p1_entry.is_none());
         let p2_entry = entry0.p2_entry().unwrap();
         assert!(p2_entry.is_none());
 
         let entry1 = revlog.get_entry(1.into()).ok().unwrap();
         assert_eq!(entry1.revision(), Revision(1));
         assert_eq!(*entry1.node(), node1);
         assert!(!entry1.has_p1());
         assert_eq!(entry1.p1(), None);
         assert_eq!(entry1.p2(), None);
         let p1_entry = entry1.p1_entry().unwrap();
         assert!(p1_entry.is_none());
         let p2_entry = entry1.p2_entry().unwrap();
         assert!(p2_entry.is_none());
 
         let entry2 = revlog.get_entry(2.into()).ok().unwrap();
         assert_eq!(entry2.revision(), Revision(2));
         assert_eq!(*entry2.node(), node2);
         assert!(entry2.has_p1());
         assert_eq!(entry2.p1(), Some(Revision(0)));
         assert_eq!(entry2.p2(), Some(Revision(1)));
         let p1_entry = entry2.p1_entry().unwrap();
         assert!(p1_entry.is_some());
         assert_eq!(p1_entry.unwrap().revision(), Revision(0));
         let p2_entry = entry2.p2_entry().unwrap();
         assert!(p2_entry.is_some());
         assert_eq!(p2_entry.unwrap().revision(), Revision(1));
     }
 
     #[test]
     fn test_nodemap() {
         let temp = tempfile::tempdir().unwrap();
         let vfs = Vfs { base: temp.path() };
 
         // building a revlog with a forced Node starting with zeros
         // This is a corruption, but it does not preclude using the nodemap
         // if we don't try and access the data
         let node0 = Node::from_hex("00d2a3912a0b24502043eae84ee4b279c18b90dd")
             .unwrap();
         let node1 = Node::from_hex("b004912a8510032a0350a74daa2803dadfb00e12")
             .unwrap();
         let entry0_bytes = IndexEntryBuilder::new()
             .is_first(true)
             .with_version(1)
             .with_inline(true)
             .with_offset(INDEX_ENTRY_SIZE)
             .with_node(node0)
             .build();
         let entry1_bytes = IndexEntryBuilder::new()
             .with_offset(INDEX_ENTRY_SIZE)
             .with_node(node1)
             .build();
         let contents = vec![entry0_bytes, entry1_bytes]
             .into_iter()
             .flatten()
             .collect_vec();
         std::fs::write(temp.path().join("foo.i"), contents).unwrap();
-        let revlog = Revlog::open(&vfs, "foo.i", None, false).unwrap();
+
+        let mut idx = nodemap::tests::TestNtIndex::new();
+        idx.insert_node(Revision(0), node0).unwrap();
+        idx.insert_node(Revision(1), node1).unwrap();
+
+        let revlog =
+            Revlog::open_gen(&vfs, "foo.i", None, true, Some(idx.nt)).unwrap();
 
         // accessing the data shows the corruption
         revlog.get_entry(0.into()).unwrap().data().unwrap_err();
 
         assert_eq!(
             revlog.rev_from_node(NULL_NODE.into()).unwrap(),
             Revision(-1)
         );
         assert_eq!(revlog.rev_from_node(node0.into()).unwrap(), Revision(0));
         assert_eq!(revlog.rev_from_node(node1.into()).unwrap(), Revision(1));
         assert_eq!(
             revlog
                 .rev_from_node(NodePrefix::from_hex("000").unwrap())
                 .unwrap(),
             Revision(-1)
         );
         assert_eq!(
             revlog
                 .rev_from_node(NodePrefix::from_hex("b00").unwrap())
                 .unwrap(),
             Revision(1)
         );
         // RevlogError does not implement PartialEq
         // (ultimately because io::Error does not)
         match revlog
             .rev_from_node(NodePrefix::from_hex("00").unwrap())
             .expect_err("Expected to give AmbiguousPrefix error")
         {
             RevlogError::AmbiguousPrefix => (),
             e => {
                 panic!("Got another error than AmbiguousPrefix: {:?}", e);
             }
         };
     }
 }

rust/hg-core/src/revlog/nodemap.rs

@@ -1,1095 +1,1102 b''
 // Copyright 2018-2020 Georges Racinet <[e-mail]>
 //           and Mercurial contributors
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 //! Indexing facilities for fast retrieval of `Revision` from `Node`
 //!
 //! This provides a variation on the 16-ary radix tree that is
 //! provided as "nodetree" in revlog.c, ready for append-only persistence
 //! on disk.
 //!
 //! Following existing implicit conventions, the "nodemap" terminology
 //! is used in a more abstract context.
 
 use crate::UncheckedRevision;
 
 use super::{
     node::NULL_NODE, Node, NodePrefix, Revision, RevlogIndex, NULL_REVISION,
 };
 
 use bytes_cast::{unaligned, BytesCast};
 use std::cmp::max;
 use std::fmt;
 use std::mem::{self, align_of, size_of};
 use std::ops::Deref;
 use std::ops::Index;
 
 #[derive(Debug, PartialEq)]
 pub enum NodeMapError {
     /// A `NodePrefix` matches several [`Revision`]s.
     ///
     /// This can be returned by methods meant for (at most) one match.
     MultipleResults,
     /// A `Revision` stored in the nodemap could not be found in the index
     RevisionNotInIndex(UncheckedRevision),
 }
 
 /// Mapping system from Mercurial nodes to revision numbers.
 ///
 /// ## `RevlogIndex` and `NodeMap`
 ///
 /// One way to think about their relationship is that
 /// the `NodeMap` is a prefix-oriented reverse index of the [`Node`]
 /// information carried by a [`RevlogIndex`].
 ///
 /// Many of the methods in this trait take a `RevlogIndex` argument
 /// which is used for validation of their results. This index must naturally
 /// be the one the `NodeMap` is about, and it must be consistent.
 ///
 /// Notably, the `NodeMap` must not store
 /// information about more `Revision` values than there are in the index.
 /// In these methods, an encountered `Revision` is not in the index, a
 /// [RevisionNotInIndex](NodeMapError) error is returned.
 ///
 /// In insert operations, the rule is thus that the `NodeMap` must always
 /// be updated after the `RevlogIndex` it is about.
 pub trait NodeMap {
     /// Find the unique `Revision` having the given `Node`
     ///
     /// If no Revision matches the given `Node`, `Ok(None)` is returned.
     fn find_node(
         &self,
         index: &impl RevlogIndex,
         node: &Node,
     ) -> Result<Option<Revision>, NodeMapError> {
         self.find_bin(index, node.into())
     }
 
     /// Find the unique Revision whose `Node` starts with a given binary prefix
     ///
     /// If no Revision matches the given prefix, `Ok(None)` is returned.
     ///
     /// If several Revisions match the given prefix, a
     /// [MultipleResults](NodeMapError)  error is returned.
     fn find_bin(
         &self,
         idx: &impl RevlogIndex,
         prefix: NodePrefix,
     ) -> Result<Option<Revision>, NodeMapError>;
 
     /// Give the size of the shortest node prefix that determines
     /// the revision uniquely.
     ///
     /// From a binary node prefix, if it is matched in the node map, this
     /// returns the number of hexadecimal digits that would had sufficed
     /// to find the revision uniquely.
     ///
     /// Returns `None` if no [`Revision`] could be found for the prefix.
     ///
     /// If several Revisions match the given prefix, a
     /// [MultipleResults](NodeMapError)  error is returned.
     fn unique_prefix_len_bin(
         &self,
         idx: &impl RevlogIndex,
         node_prefix: NodePrefix,
     ) -> Result<Option<usize>, NodeMapError>;
 
     /// Same as [unique_prefix_len_bin](Self::unique_prefix_len_bin), with
     /// a full [`Node`] as input
     fn unique_prefix_len_node(
         &self,
         idx: &impl RevlogIndex,
         node: &Node,
     ) -> Result<Option<usize>, NodeMapError> {
         self.unique_prefix_len_bin(idx, node.into())
     }
 }
 
 pub trait MutableNodeMap: NodeMap {
     fn insert<I: RevlogIndex>(
         &mut self,
         index: &I,
         node: &Node,
         rev: Revision,
     ) -> Result<(), NodeMapError>;
 }
 
 /// Low level NodeTree [`Block`] elements
 ///
 /// These are exactly as for instance on persistent storage.
 type RawElement = unaligned::I32Be;
 
 /// High level representation of values in NodeTree
 /// [`Blocks`](struct.Block.html)
 ///
 /// This is the high level representation that most algorithms should
 /// use.
 #[derive(Clone, Debug, Eq, PartialEq)]
 enum Element {
     // This is not a Mercurial revision. It's a `i32` because this is the
     // right type for this structure.
     Rev(i32),
     Block(usize),
     None,
 }
 
 impl From<RawElement> for Element {
     /// Conversion from low level representation, after endianness conversion.
     ///
     /// See [`Block`](struct.Block.html) for explanation about the encoding.
     fn from(raw: RawElement) -> Element {
         let int = raw.get();
         if int >= 0 {
             Element::Block(int as usize)
         } else if int == -1 {
             Element::None
         } else {
             Element::Rev(-int - 2)
         }
     }
 }
 
 impl From<Element> for RawElement {
     fn from(element: Element) -> RawElement {
         RawElement::from(match element {
             Element::None => 0,
             Element::Block(i) => i as i32,
             Element::Rev(rev) => -rev - 2,
         })
     }
 }
 
 const ELEMENTS_PER_BLOCK: usize = 16; // number of different values in a nybble
 
 /// A logical block of the [`NodeTree`], packed with a fixed size.
 ///
 /// These are always used in container types implementing `Index<Block>`,
 /// such as `&Block`
 ///
 /// As an array of integers, its ith element encodes that the
 /// ith potential edge from the block, representing the ith hexadecimal digit
 /// (nybble) `i` is either:
 ///
 /// - absent (value -1)
 /// - another `Block` in the same indexable container (value ≥ 0)
 ///  - a [`Revision`] leaf (value ≤ -2)
 ///
 /// Endianness has to be fixed for consistency on shared storage across
 /// different architectures.
 ///
 /// A key difference with the C `nodetree` is that we need to be
 /// able to represent the [`Block`] at index 0, hence -1 is the empty marker
 /// rather than 0 and the [`Revision`] range upper limit of -2 instead of -1.
 ///
 /// Another related difference is that `NULL_REVISION` (-1) is not
 /// represented at all, because we want an immutable empty nodetree
 /// to be valid.
 #[derive(Copy, Clone, BytesCast, PartialEq)]
 #[repr(transparent)]
 pub struct Block([RawElement; ELEMENTS_PER_BLOCK]);
 
 impl Block {
     fn new() -> Self {
         let absent_node = RawElement::from(-1);
         Block([absent_node; ELEMENTS_PER_BLOCK])
     }
 
     fn get(&self, nybble: u8) -> Element {
         self.0[nybble as usize].into()
     }
 
     fn set(&mut self, nybble: u8, element: Element) {
         self.0[nybble as usize] = element.into()
     }
 }
 
 impl fmt::Debug for Block {
     /// sparse representation for testing and debugging purposes
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_map()
             .entries((0..16).filter_map(|i| match self.get(i) {
                 Element::None => None,
                 element => Some((i, element)),
             }))
             .finish()
     }
 }
 
 /// A mutable 16-radix tree with the root block logically at the end
 ///
 /// Because of the append only nature of our node trees, we need to
 /// keep the original untouched and store new blocks separately.
 ///
 /// The mutable root [`Block`] is kept apart so that we don't have to rebump
 /// it on each insertion.
 pub struct NodeTree {
     readonly: Box<dyn Deref<Target = [Block]> + Send>,
     growable: Vec<Block>,
     root: Block,
     masked_inner_blocks: usize,
 }
 
 impl Index<usize> for NodeTree {
     type Output = Block;
 
     fn index(&self, i: usize) -> &Block {
         let ro_len = self.readonly.len();
         if i < ro_len {
             &self.readonly[i]
         } else if i == ro_len + self.growable.len() {
             &self.root
         } else {
             &self.growable[i - ro_len]
         }
     }
 }
 
 /// Return `None` unless the [`Node`] for `rev` has given prefix in `idx`.
 fn has_prefix_or_none(
     idx: &impl RevlogIndex,
     prefix: NodePrefix,
     rev: UncheckedRevision,
 ) -> Result<Option<Revision>, NodeMapError> {
     match idx.check_revision(rev) {
         Some(checked) => idx
             .node(checked)
             .ok_or(NodeMapError::RevisionNotInIndex(rev))
             .map(|node| {
                 if prefix.is_prefix_of(node) {
                     Some(checked)
                 } else {
                     None
                 }
             }),
         None => Err(NodeMapError::RevisionNotInIndex(rev)),
     }
 }
 
 /// validate that the candidate's node starts indeed with given prefix,
 /// and treat ambiguities related to [`NULL_REVISION`].
 ///
 /// From the data in the NodeTree, one can only conclude that some
 /// revision is the only one for a *subprefix* of the one being looked up.
 fn validate_candidate(
     idx: &impl RevlogIndex,
     prefix: NodePrefix,
     candidate: (Option<UncheckedRevision>, usize),
 ) -> Result<(Option<Revision>, usize), NodeMapError> {
     let (rev, steps) = candidate;
     if let Some(nz_nybble) = prefix.first_different_nybble(&NULL_NODE) {
         rev.map_or(Ok((None, steps)), |r| {
             has_prefix_or_none(idx, prefix, r)
                 .map(|opt| (opt, max(steps, nz_nybble + 1)))
         })
     } else {
         // the prefix is only made of zeros; NULL_REVISION always matches it
         // and any other *valid* result is an ambiguity
         match rev {
             None => Ok((Some(NULL_REVISION), steps + 1)),
             Some(r) => match has_prefix_or_none(idx, prefix, r)? {
                 None => Ok((Some(NULL_REVISION), steps + 1)),
                 _ => Err(NodeMapError::MultipleResults),
             },
         }
     }
 }
 
 impl NodeTree {
     /// Initiate a NodeTree from an immutable slice-like of `Block`
     ///
     /// We keep `readonly` and clone its root block if it isn't empty.
     fn new(readonly: Box<dyn Deref<Target = [Block]> + Send>) -> Self {
         let root = readonly.last().cloned().unwrap_or_else(Block::new);
         NodeTree {
             readonly,
             growable: Vec::new(),
             root,
             masked_inner_blocks: 0,
         }
     }
 
     /// Create from an opaque bunch of bytes
     ///
     /// The created [`NodeTreeBytes`] from `bytes`,
     /// of which exactly `amount` bytes are used.
     ///
     /// - `buffer` could be derived from `PyBuffer` and `Mmap` objects.
     /// - `amount` is expressed in bytes, and is not automatically derived from
     ///   `bytes`, so that a caller that manages them atomically can perform
     ///   temporary disk serializations and still rollback easily if needed.
     ///   First use-case for this would be to support Mercurial shell hooks.
     ///
     /// panics if `buffer` is smaller than `amount`
     pub fn load_bytes(
         bytes: Box<dyn Deref<Target = [u8]> + Send>,
         amount: usize,
     ) -> Self {
         NodeTree::new(Box::new(NodeTreeBytes::new(bytes, amount)))
     }
 
     /// Retrieve added [`Block`]s and the original immutable data
     pub fn into_readonly_and_added(
         self,
     ) -> (Box<dyn Deref<Target = [Block]> + Send>, Vec<Block>) {
         let mut vec = self.growable;
         let readonly = self.readonly;
         if readonly.last() != Some(&self.root) {
             vec.push(self.root);
         }
         (readonly, vec)
     }
 
     /// Retrieve added [`Block]s as bytes, ready to be written to persistent
     /// storage
     pub fn into_readonly_and_added_bytes(
         self,
     ) -> (Box<dyn Deref<Target = [Block]> + Send>, Vec<u8>) {
         let (readonly, vec) = self.into_readonly_and_added();
         // Prevent running `v`'s destructor so we are in complete control
         // of the allocation.
         let vec = mem::ManuallyDrop::new(vec);
 
         // Transmute the `Vec<Block>` to a `Vec<u8>`. Blocks are contiguous
         // bytes, so this is perfectly safe.
         let bytes = unsafe {
             // Check for compatible allocation layout.
             // (Optimized away by constant-folding + dead code elimination.)
             assert_eq!(size_of::<Block>(), 64);
             assert_eq!(align_of::<Block>(), 1);
 
             // /!\ Any use of `vec` after this is use-after-free.
             // TODO: use `into_raw_parts` once stabilized
             Vec::from_raw_parts(
                 vec.as_ptr() as *mut u8,
                 vec.len() * size_of::<Block>(),
                 vec.capacity() * size_of::<Block>(),
             )
         };
         (readonly, bytes)
     }
 
     /// Total number of blocks
     fn len(&self) -> usize {
         self.readonly.len() + self.growable.len() + 1
     }
 
     /// Implemented for completeness
     ///
     /// A `NodeTree` always has at least the mutable root block.
     #[allow(dead_code)]
     fn is_empty(&self) -> bool {
         false
     }
 
     /// Main working method for `NodeTree` searches
     ///
     /// The first returned value is the result of analysing `NodeTree` data
     /// *alone*: whereas `None` guarantees that the given prefix is absent
     /// from the [`NodeTree`] data (but still could match [`NULL_NODE`]), with
     /// `Some(rev)`, it is to be understood that `rev` is the unique
     /// [`Revision`] that could match the prefix. Actually, all that can
     /// be inferred from
     /// the `NodeTree` data is that `rev` is the revision with the longest
     /// common node prefix with the given prefix.
     /// We return an [`UncheckedRevision`] because we have no guarantee that
     /// the revision we found is valid for the index.
     ///
     /// The second returned value is the size of the smallest subprefix
     /// of `prefix` that would give the same result, i.e. not the
     /// [MultipleResults](NodeMapError) error variant (again, using only the
     /// data of the [`NodeTree`]).
     fn lookup(
         &self,
         prefix: NodePrefix,
     ) -> Result<(Option<UncheckedRevision>, usize), NodeMapError> {
         for (i, visit_item) in self.visit(prefix).enumerate() {
             if let Some(opt) = visit_item.final_revision() {
                 return Ok((opt, i + 1));
             }
         }
         Err(NodeMapError::MultipleResults)
     }
 
     fn visit(&self, prefix: NodePrefix) -> NodeTreeVisitor {
         NodeTreeVisitor {
             nt: self,
             prefix,
             visit: self.len() - 1,
             nybble_idx: 0,
             done: false,
         }
     }
     /// Return a mutable reference for `Block` at index `idx`.
     ///
     /// If `idx` lies in the immutable area, then the reference is to
     /// a newly appended copy.
     ///
     /// Returns (new_idx, glen, mut_ref) where
     ///
     /// - `new_idx` is the index of the mutable `Block`
     /// - `mut_ref` is a mutable reference to the mutable Block.
     /// - `glen` is the new length of `self.growable`
     ///
     /// Note: the caller wouldn't be allowed to query `self.growable.len()`
     /// itself because of the mutable borrow taken with the returned `Block`
     fn mutable_block(&mut self, idx: usize) -> (usize, &mut Block, usize) {
         let ro_blocks = &self.readonly;
         let ro_len = ro_blocks.len();
         let glen = self.growable.len();
         if idx < ro_len {
             self.masked_inner_blocks += 1;
             self.growable.push(ro_blocks[idx]);
             (glen + ro_len, &mut self.growable[glen], glen + 1)
         } else if glen + ro_len == idx {
             (idx, &mut self.root, glen)
         } else {
             (idx, &mut self.growable[idx - ro_len], glen)
         }
     }
 
     /// Main insertion method
     ///
     /// This will dive in the node tree to find the deepest `Block` for
     /// `node`, split it as much as needed and record `node` in there.
     /// The method then backtracks, updating references in all the visited
     /// blocks from the root.
     ///
     /// All the mutated `Block` are copied first to the growable part if
     /// needed. That happens for those in the immutable part except the root.
     pub fn insert<I: RevlogIndex>(
         &mut self,
         index: &I,
         node: &Node,
         rev: Revision,
     ) -> Result<(), NodeMapError> {
         let ro_len = &self.readonly.len();
 
         let mut visit_steps: Vec<_> = self.visit(node.into()).collect();
         let read_nybbles = visit_steps.len();
         // visit_steps cannot be empty, since we always visit the root block
         let deepest = visit_steps.pop().unwrap();
 
         let (mut block_idx, mut block, mut glen) =
             self.mutable_block(deepest.block_idx);
 
         if let Element::Rev(old_rev) = deepest.element {
             let old_node = index
                 .check_revision(old_rev.into())
                 .and_then(|rev| index.node(rev))
                 .ok_or_else(|| {
                     NodeMapError::RevisionNotInIndex(old_rev.into())
                 })?;
             if old_node == node {
                 return Ok(()); // avoid creating lots of useless blocks
             }
 
             // Looping over the tail of nybbles in both nodes, creating
             // new blocks until we find the difference
             let mut new_block_idx = ro_len + glen;
             let mut nybble = deepest.nybble;
             for nybble_pos in read_nybbles..node.nybbles_len() {
                 block.set(nybble, Element::Block(new_block_idx));
 
                 let new_nybble = node.get_nybble(nybble_pos);
                 let old_nybble = old_node.get_nybble(nybble_pos);
 
                 if old_nybble == new_nybble {
                     self.growable.push(Block::new());
                     block = &mut self.growable[glen];
                     glen += 1;
                     new_block_idx += 1;
                     nybble = new_nybble;
                 } else {
                     let mut new_block = Block::new();
                     new_block.set(old_nybble, Element::Rev(old_rev));
                     new_block.set(new_nybble, Element::Rev(rev.0));
                     self.growable.push(new_block);
                     break;
                 }
             }
         } else {
             // Free slot in the deepest block: no splitting has to be done
             block.set(deepest.nybble, Element::Rev(rev.0));
         }
 
         // Backtrack over visit steps to update references
         while let Some(visited) = visit_steps.pop() {
             let to_write = Element::Block(block_idx);
             if visit_steps.is_empty() {
                 self.root.set(visited.nybble, to_write);
                 break;
             }
             let (new_idx, block, _) = self.mutable_block(visited.block_idx);
             if block.get(visited.nybble) == to_write {
                 break;
             }
             block.set(visited.nybble, to_write);
             block_idx = new_idx;
         }
         Ok(())
     }
 
     /// Make the whole `NodeTree` logically empty, without touching the
     /// immutable part.
     pub fn invalidate_all(&mut self) {
         self.root = Block::new();
         self.growable = Vec::new();
         self.masked_inner_blocks = self.readonly.len();
     }
 
     /// Return the number of blocks in the readonly part that are currently
     /// masked in the mutable part.
     ///
     /// The `NodeTree` structure has no efficient way to know how many blocks
     /// are already unreachable in the readonly part.
     ///
     /// After a call to `invalidate_all()`, the returned number can be actually
     /// bigger than the whole readonly part, a conventional way to mean that
     /// all the readonly blocks have been masked. This is what is really
     /// useful to the caller and does not require to know how many were
     /// actually unreachable to begin with.
     pub fn masked_readonly_blocks(&self) -> usize {
         if let Some(readonly_root) = self.readonly.last() {
             if readonly_root == &self.root {
                 return 0;
             }
         } else {
             return 0;
         }
         self.masked_inner_blocks + 1
     }
 }
 
 pub struct NodeTreeBytes {
     buffer: Box<dyn Deref<Target = [u8]> + Send>,
     len_in_blocks: usize,
 }
 
 impl NodeTreeBytes {
     fn new(
         buffer: Box<dyn Deref<Target = [u8]> + Send>,
         amount: usize,
     ) -> Self {
         assert!(buffer.len() >= amount);
         let len_in_blocks = amount / size_of::<Block>();
         NodeTreeBytes {
             buffer,
             len_in_blocks,
         }
     }
 }
 
 impl Deref for NodeTreeBytes {
     type Target = [Block];
 
     fn deref(&self) -> &[Block] {
         Block::slice_from_bytes(&self.buffer, self.len_in_blocks)
             // `NodeTreeBytes::new` already asserted that `self.buffer` is
             // large enough.
             .unwrap()
             .0
     }
 }
 
 struct NodeTreeVisitor<'n> {
     nt: &'n NodeTree,
     prefix: NodePrefix,
     visit: usize,
     nybble_idx: usize,
     done: bool,
 }
 
 #[derive(Debug, PartialEq, Clone)]
 struct NodeTreeVisitItem {
     block_idx: usize,
     nybble: u8,
     element: Element,
 }
 
 impl<'n> Iterator for NodeTreeVisitor<'n> {
     type Item = NodeTreeVisitItem;
 
     fn next(&mut self) -> Option<Self::Item> {
         if self.done || self.nybble_idx >= self.prefix.nybbles_len() {
             return None;
         }
 
         let nybble = self.prefix.get_nybble(self.nybble_idx);
         self.nybble_idx += 1;
 
         let visit = self.visit;
         let element = self.nt[visit].get(nybble);
         if let Element::Block(idx) = element {
             self.visit = idx;
         } else {
             self.done = true;
         }
 
         Some(NodeTreeVisitItem {
             block_idx: visit,
             nybble,
             element,
         })
     }
 }
 
 impl NodeTreeVisitItem {
     // Return `Some(opt)` if this item is final, with `opt` being the
     // `UncheckedRevision` that it may represent.
     //
     // If the item is not terminal, return `None`
     fn final_revision(&self) -> Option<Option<UncheckedRevision>> {
         match self.element {
             Element::Block(_) => None,
             Element::Rev(r) => Some(Some(r.into())),
             Element::None => Some(None),
         }
     }
 }
 
 impl From<Vec<Block>> for NodeTree {
     fn from(vec: Vec<Block>) -> Self {
         Self::new(Box::new(vec))
     }
 }
 
 impl fmt::Debug for NodeTree {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let readonly: &[Block] = &*self.readonly;
         write!(
             f,
             "readonly: {:?}, growable: {:?}, root: {:?}",
             readonly, self.growable, self.root
         )
     }
 }
 
 impl Default for NodeTree {
     /// Create a fully mutable empty NodeTree
     fn default() -> Self {
         NodeTree::new(Box::new(Vec::new()))
     }
 }
 
 impl NodeMap for NodeTree {
     fn find_bin<'a>(
         &self,
         idx: &impl RevlogIndex,
         prefix: NodePrefix,
     ) -> Result<Option<Revision>, NodeMapError> {
         validate_candidate(idx, prefix, self.lookup(prefix)?)
             .map(|(opt, _shortest)| opt)
     }
 
     fn unique_prefix_len_bin<'a>(
         &self,
         idx: &impl RevlogIndex,
         prefix: NodePrefix,
     ) -> Result<Option<usize>, NodeMapError> {
         validate_candidate(idx, prefix, self.lookup(prefix)?)
             .map(|(opt, shortest)| opt.map(|_rev| shortest))
     }
 }
 
 #[cfg(test)]
-mod tests {
+pub mod tests {
     use super::NodeMapError::*;
     use super::*;
     use crate::revlog::node::{hex_pad_right, Node};
     use std::collections::HashMap;
 
     /// Creates a `Block` using a syntax close to the `Debug` output
     macro_rules! block {
         {$($nybble:tt : $variant:ident($val:tt)),*} => (
             {
                 let mut block = Block::new();
                 $(block.set($nybble, Element::$variant($val)));*;
                 block
             }
         )
     }
 
     /// Shorthand to reduce boilerplate when creating [`Revision`] for testing
     macro_rules! R {
         ($revision:literal) => {
             Revision($revision)
         };
     }
 
     #[test]
     fn test_block_debug() {
         let mut block = Block::new();
         block.set(1, Element::Rev(3));
         block.set(10, Element::Block(0));
         assert_eq!(format!("{:?}", block), "{1: Rev(3), 10: Block(0)}");
     }
 
     #[test]
     fn test_block_macro() {
         let block = block! {5: Block(2)};
         assert_eq!(format!("{:?}", block), "{5: Block(2)}");
 
         let block = block! {13: Rev(15), 5: Block(2)};
         assert_eq!(format!("{:?}", block), "{5: Block(2), 13: Rev(15)}");
     }
 
     #[test]
     fn test_raw_block() {
         let mut raw = [255u8; 64];
 
         let mut counter = 0;
         for val in [0_i32, 15, -2, -1, -3].iter() {
             for byte in val.to_be_bytes().iter() {
                 raw[counter] = *byte;
                 counter += 1;
             }
         }
         let (block, _) = Block::from_bytes(&raw).unwrap();
         assert_eq!(block.get(0), Element::Block(0));
         assert_eq!(block.get(1), Element::Block(15));
         assert_eq!(block.get(3), Element::None);
         assert_eq!(block.get(2), Element::Rev(0));
         assert_eq!(block.get(4), Element::Rev(1));
     }
 
     type TestIndex = HashMap<UncheckedRevision, Node>;
 
     impl RevlogIndex for TestIndex {
         fn node(&self, rev: Revision) -> Option<&Node> {
             self.get(&rev.into())
         }
 
         fn len(&self) -> usize {
             self.len()
         }
 
         fn check_revision(&self, rev: UncheckedRevision) -> Option<Revision> {
             self.get(&rev).map(|_| Revision(rev.0))
         }
     }
 
     /// Pad hexadecimal Node prefix with zeros on the right
     ///
     /// This avoids having to repeatedly write very long hexadecimal
     /// strings for test data, and brings actual hash size independency.
     #[cfg(test)]
     fn pad_node(hex: &str) -> Node {
         Node::from_hex(&hex_pad_right(hex)).unwrap()
     }
 
     /// Pad hexadecimal Node prefix with zeros on the right, then insert
     fn pad_insert(idx: &mut TestIndex, rev: Revision, hex: &str) {
         idx.insert(rev.into(), pad_node(hex));
     }
 
     fn sample_nodetree() -> NodeTree {
         NodeTree::from(vec![
             block![0: Rev(9)],
             block![0: Rev(0), 1: Rev(9)],
             block![0: Block(1), 1:Rev(1)],
         ])
     }
 
     fn hex(s: &str) -> NodePrefix {
         NodePrefix::from_hex(s).unwrap()
     }
 
     #[test]
     fn test_nt_debug() {
         let nt = sample_nodetree();
         assert_eq!(
             format!("{:?}", nt),
             "readonly: \
              [{0: Rev(9)}, {0: Rev(0), 1: Rev(9)}, {0: Block(1), 1: Rev(1)}], \
              growable: [], \
              root: {0: Block(1), 1: Rev(1)}",
         );
     }
 
     #[test]
     fn test_immutable_find_simplest() -> Result<(), NodeMapError> {
         let mut idx: TestIndex = HashMap::new();
         pad_insert(&mut idx, R!(1), "1234deadcafe");
 
         let nt = NodeTree::from(vec![block! {1: Rev(1)}]);
         assert_eq!(nt.find_bin(&idx, hex("1"))?, Some(R!(1)));
         assert_eq!(nt.find_bin(&idx, hex("12"))?, Some(R!(1)));
         assert_eq!(nt.find_bin(&idx, hex("1234de"))?, Some(R!(1)));
         assert_eq!(nt.find_bin(&idx, hex("1a"))?, None);
         assert_eq!(nt.find_bin(&idx, hex("ab"))?, None);
 
         // and with full binary Nodes
         assert_eq!(
             nt.find_node(&idx, idx.get(&1.into()).unwrap())?,
             Some(R!(1))
         );
         let unknown = Node::from_hex(&hex_pad_right("3d")).unwrap();
         assert_eq!(nt.find_node(&idx, &unknown)?, None);
         Ok(())
     }
 
     #[test]
     fn test_immutable_find_one_jump() {
         let mut idx = TestIndex::new();
         pad_insert(&mut idx, R!(9), "012");
         pad_insert(&mut idx, R!(0), "00a");
 
         let nt = sample_nodetree();
 
         assert_eq!(nt.find_bin(&idx, hex("0")), Err(MultipleResults));
         assert_eq!(nt.find_bin(&idx, hex("01")), Ok(Some(R!(9))));
         assert_eq!(nt.find_bin(&idx, hex("00")), Err(MultipleResults));
         assert_eq!(nt.find_bin(&idx, hex("00a")), Ok(Some(R!(0))));
         assert_eq!(nt.unique_prefix_len_bin(&idx, hex("00a")), Ok(Some(3)));
         assert_eq!(nt.find_bin(&idx, hex("000")), Ok(Some(NULL_REVISION)));
     }
 
     #[test]
     fn test_mutated_find() -> Result<(), NodeMapError> {
         let mut idx = TestIndex::new();
         pad_insert(&mut idx, R!(9), "012");
         pad_insert(&mut idx, R!(0), "00a");
         pad_insert(&mut idx, R!(2), "cafe");
         pad_insert(&mut idx, R!(3), "15");
         pad_insert(&mut idx, R!(1), "10");
 
         let nt = NodeTree {
             readonly: sample_nodetree().readonly,
             growable: vec![block![0: Rev(1), 5: Rev(3)]],
             root: block![0: Block(1), 1:Block(3), 12: Rev(2)],
             masked_inner_blocks: 1,
         };
         assert_eq!(nt.find_bin(&idx, hex("10"))?, Some(R!(1)));
         assert_eq!(nt.find_bin(&idx, hex("c"))?, Some(R!(2)));
         assert_eq!(nt.unique_prefix_len_bin(&idx, hex("c"))?, Some(1));
         assert_eq!(nt.find_bin(&idx, hex("00")), Err(MultipleResults));
         assert_eq!(nt.find_bin(&idx, hex("000"))?, Some(NULL_REVISION));
         assert_eq!(nt.unique_prefix_len_bin(&idx, hex("000"))?, Some(3));
         assert_eq!(nt.find_bin(&idx, hex("01"))?, Some(R!(9)));
         assert_eq!(nt.masked_readonly_blocks(), 2);
         Ok(())
     }
 
-    struct TestNtIndex {
-        index: TestIndex,
-        nt: NodeTree,
+    pub struct TestNtIndex {
+        pub index: TestIndex,
+        pub nt: NodeTree,
     }
 
     impl TestNtIndex {
-        fn new() -> Self {
+        pub fn new() -> Self {
             TestNtIndex {
                 index: HashMap::new(),
                 nt: NodeTree::default(),
             }
         }
 
-        fn insert(&mut self, rev: i32, hex: &str) -> Result<(), NodeMapError> {
+        pub fn insert_node(
+            &mut self,
+            rev: Revision,
+            node: Node,
+        ) -> Result<(), NodeMapError> {
+            self.index.insert(rev.into(), node);
+            self.nt.insert(&self.index, &node, rev)?;
+            Ok(())
+        }
+
+        pub fn insert(
+            &mut self,
+            rev: Revision,
+            hex: &str,
+        ) -> Result<(), NodeMapError> {
             let node = pad_node(hex);
-            let rev: UncheckedRevision = rev.into();
-            self.index.insert(rev, node);
-            self.nt.insert(
-                &self.index,
-                &node,
-                self.index.check_revision(rev).unwrap(),
-            )?;
-            Ok(())
+            return self.insert_node(rev, node);
         }
 
         fn find_hex(
             &self,
             prefix: &str,
         ) -> Result<Option<Revision>, NodeMapError> {
             self.nt.find_bin(&self.index, hex(prefix))
         }
 
         fn unique_prefix_len_hex(
             &self,
             prefix: &str,
         ) -> Result<Option<usize>, NodeMapError> {
             self.nt.unique_prefix_len_bin(&self.index, hex(prefix))
         }
 
         /// Drain `added` and restart a new one
         fn commit(self) -> Self {
             let mut as_vec: Vec<Block> =
                 self.nt.readonly.iter().copied().collect();
             as_vec.extend(self.nt.growable);
             as_vec.push(self.nt.root);
 
             Self {
                 index: self.index,
                 nt: NodeTree::from(as_vec),
             }
         }
     }
 
     #[test]
     fn test_insert_full_mutable() -> Result<(), NodeMapError> {
         let mut idx = TestNtIndex::new();
-        idx.insert(0, "1234")?;
+        idx.insert(Revision(0), "1234")?;
         assert_eq!(idx.find_hex("1")?, Some(R!(0)));
         assert_eq!(idx.find_hex("12")?, Some(R!(0)));
 
         // let's trigger a simple split
-        idx.insert(1, "1a34")?;
+        idx.insert(Revision(1), "1a34")?;
         assert_eq!(idx.nt.growable.len(), 1);
         assert_eq!(idx.find_hex("12")?, Some(R!(0)));
         assert_eq!(idx.find_hex("1a")?, Some(R!(1)));
 
         // reinserting is a no_op
-        idx.insert(1, "1a34")?;
+        idx.insert(Revision(1), "1a34")?;
         assert_eq!(idx.nt.growable.len(), 1);
         assert_eq!(idx.find_hex("12")?, Some(R!(0)));
         assert_eq!(idx.find_hex("1a")?, Some(R!(1)));
 
-        idx.insert(2, "1a01")?;
+        idx.insert(Revision(2), "1a01")?;
         assert_eq!(idx.nt.growable.len(), 2);
         assert_eq!(idx.find_hex("1a"), Err(NodeMapError::MultipleResults));
         assert_eq!(idx.find_hex("12")?, Some(R!(0)));
         assert_eq!(idx.find_hex("1a3")?, Some(R!(1)));
         assert_eq!(idx.find_hex("1a0")?, Some(R!(2)));
         assert_eq!(idx.find_hex("1a12")?, None);
 
         // now let's make it split and create more than one additional block
-        idx.insert(3, "1a345")?;
+        idx.insert(Revision(3), "1a345")?;
         assert_eq!(idx.nt.growable.len(), 4);
         assert_eq!(idx.find_hex("1a340")?, Some(R!(1)));
         assert_eq!(idx.find_hex("1a345")?, Some(R!(3)));
         assert_eq!(idx.find_hex("1a341")?, None);
 
         // there's no readonly block to mask
         assert_eq!(idx.nt.masked_readonly_blocks(), 0);
         Ok(())
     }
 
     #[test]
     fn test_unique_prefix_len_zero_prefix() {
         let mut idx = TestNtIndex::new();
-        idx.insert(0, "00000abcd").unwrap();
+        idx.insert(Revision(0), "00000abcd").unwrap();
 
         assert_eq!(idx.find_hex("000"), Err(NodeMapError::MultipleResults));
         // in the nodetree proper, this will be found at the first nybble
         // yet the correct answer for unique_prefix_len is not 1, nor 1+1,
         // but the first difference with `NULL_NODE`
         assert_eq!(idx.unique_prefix_len_hex("00000a"), Ok(Some(6)));
         assert_eq!(idx.unique_prefix_len_hex("00000ab"), Ok(Some(6)));
 
         // same with odd result
-        idx.insert(1, "00123").unwrap();
+        idx.insert(Revision(1), "00123").unwrap();
         assert_eq!(idx.unique_prefix_len_hex("001"), Ok(Some(3)));
         assert_eq!(idx.unique_prefix_len_hex("0012"), Ok(Some(3)));
 
         // these are unchanged of course
         assert_eq!(idx.unique_prefix_len_hex("00000a"), Ok(Some(6)));
         assert_eq!(idx.unique_prefix_len_hex("00000ab"), Ok(Some(6)));
     }
 
     #[test]
     fn test_insert_extreme_splitting() -> Result<(), NodeMapError> {
         // check that the splitting loop is long enough
         let mut nt_idx = TestNtIndex::new();
         let nt = &mut nt_idx.nt;
         let idx = &mut nt_idx.index;
 
         let node0_hex = hex_pad_right("444444");
         let mut node1_hex = hex_pad_right("444444");
         node1_hex.pop();
         node1_hex.push('5');
         let node0 = Node::from_hex(&node0_hex).unwrap();
         let node1 = Node::from_hex(&node1_hex).unwrap();
 
         idx.insert(0.into(), node0);
         nt.insert(idx, &node0, R!(0))?;
         idx.insert(1.into(), node1);
         nt.insert(idx, &node1, R!(1))?;
 
         assert_eq!(nt.find_bin(idx, (&node0).into())?, Some(R!(0)));
         assert_eq!(nt.find_bin(idx, (&node1).into())?, Some(R!(1)));
         Ok(())
     }
 
     #[test]
     fn test_insert_partly_immutable() -> Result<(), NodeMapError> {
         let mut idx = TestNtIndex::new();
-        idx.insert(0, "1234")?;
-        idx.insert(1, "1235")?;
-        idx.insert(2, "131")?;
-        idx.insert(3, "cafe")?;
+        idx.insert(Revision(0), "1234")?;
+        idx.insert(Revision(1), "1235")?;
+        idx.insert(Revision(2), "131")?;
+        idx.insert(Revision(3), "cafe")?;
         let mut idx = idx.commit();
         assert_eq!(idx.find_hex("1234")?, Some(R!(0)));
         assert_eq!(idx.find_hex("1235")?, Some(R!(1)));
         assert_eq!(idx.find_hex("131")?, Some(R!(2)));
         assert_eq!(idx.find_hex("cafe")?, Some(R!(3)));
         // we did not add anything since init from readonly
         assert_eq!(idx.nt.masked_readonly_blocks(), 0);
 
-        idx.insert(4, "123A")?;
+        idx.insert(Revision(4), "123A")?;
         assert_eq!(idx.find_hex("1234")?, Some(R!(0)));
         assert_eq!(idx.find_hex("1235")?, Some(R!(1)));
         assert_eq!(idx.find_hex("131")?, Some(R!(2)));
         assert_eq!(idx.find_hex("cafe")?, Some(R!(3)));
         assert_eq!(idx.find_hex("123A")?, Some(R!(4)));
         // we masked blocks for all prefixes of "123", including the root
         assert_eq!(idx.nt.masked_readonly_blocks(), 4);
 
         eprintln!("{:?}", idx.nt);
-        idx.insert(5, "c0")?;
+        idx.insert(Revision(5), "c0")?;
         assert_eq!(idx.find_hex("cafe")?, Some(R!(3)));
         assert_eq!(idx.find_hex("c0")?, Some(R!(5)));
         assert_eq!(idx.find_hex("c1")?, None);
         assert_eq!(idx.find_hex("1234")?, Some(R!(0)));
         // inserting "c0" is just splitting the 'c' slot of the mutable root,
         // it doesn't mask anything
         assert_eq!(idx.nt.masked_readonly_blocks(), 4);
 
         Ok(())
     }
 
     #[test]
     fn test_invalidate_all() -> Result<(), NodeMapError> {
         let mut idx = TestNtIndex::new();
-        idx.insert(0, "1234")?;
-        idx.insert(1, "1235")?;
-        idx.insert(2, "131")?;
-        idx.insert(3, "cafe")?;
+        idx.insert(Revision(0), "1234")?;
+        idx.insert(Revision(1), "1235")?;
+        idx.insert(Revision(2), "131")?;
+        idx.insert(Revision(3), "cafe")?;
         let mut idx = idx.commit();
 
         idx.nt.invalidate_all();
 
         assert_eq!(idx.find_hex("1234")?, None);
         assert_eq!(idx.find_hex("1235")?, None);
         assert_eq!(idx.find_hex("131")?, None);
         assert_eq!(idx.find_hex("cafe")?, None);
         // all the readonly blocks have been masked, this is the
         // conventional expected response
         assert_eq!(idx.nt.masked_readonly_blocks(), idx.nt.readonly.len() + 1);
         Ok(())
     }
 
     #[test]
     fn test_into_added_empty() {
         assert!(sample_nodetree().into_readonly_and_added().1.is_empty());
         assert!(sample_nodetree()
             .into_readonly_and_added_bytes()
             .1
             .is_empty());
     }
 
     #[test]
     fn test_into_added_bytes() -> Result<(), NodeMapError> {
         let mut idx = TestNtIndex::new();
-        idx.insert(0, "1234")?;
+        idx.insert(Revision(0), "1234")?;
         let mut idx = idx.commit();
-        idx.insert(4, "cafe")?;
+        idx.insert(Revision(4), "cafe")?;
         let (_, bytes) = idx.nt.into_readonly_and_added_bytes();
 
         // only the root block has been changed
         assert_eq!(bytes.len(), size_of::<Block>());
         // big endian for -2
         assert_eq!(&bytes[4..2 * 4], [255, 255, 255, 254]);
         // big endian for -6
         assert_eq!(&bytes[12 * 4..13 * 4], [255, 255, 255, 250]);
         Ok(())
     }
 }

tests/test-contrib-perf.t

@@ -1,483 +1,483 b''
 #require test-repo
 
 Set vars:
 
   $ . "$TESTDIR/helpers-testrepo.sh"
   $ CONTRIBDIR="$TESTDIR/../contrib"
 
 Prepare repo:
 
   $ hg init
 
   $ echo this is file a > a
   $ hg add a
   $ hg commit -m first
 
   $ echo adding to file a >> a
   $ hg commit -m second
 
   $ echo adding more to file a >> a
   $ hg commit -m third
 
   $ hg up -r 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo merge-this >> a
   $ hg commit -m merge-able
   created new head
 
   $ hg up -r 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 perfstatus
 
   $ cat >> $HGRCPATH << EOF
   > [extensions]
   > perf=$CONTRIBDIR/perf.py
   > [perf]
   > presleep=0
   > stub=on
   > parentscount=1
   > EOF
   $ hg help -e perf
   perf extension - helper extension to measure performance
   
   Configurations
   ==============
   
   "perf"
   ------
   
   "all-timing"
       When set, additional statistics will be reported for each benchmark: best,
       worst, median average. If not set only the best timing is reported
       (default: off).
   
   "presleep"
     number of second to wait before any group of runs (default: 1)
   
   "pre-run"
     number of run to perform before starting measurement.
   
   "profile-benchmark"
     Enable profiling for the benchmarked section. (The first iteration is
     benchmarked)
   
   "run-limits"
     Control the number of runs each benchmark will perform. The option value
     should be a list of '<time>-<numberofrun>' pairs. After each run the
     conditions are considered in order with the following logic:
   
         If benchmark has been running for <time> seconds, and we have performed
         <numberofrun> iterations, stop the benchmark,
   
     The default value is: '3.0-100, 10.0-3'
   
   "stub"
       When set, benchmarks will only be run once, useful for testing (default:
       off)
   
   list of commands:
   
    perf::addremove
                  (no help text available)
    perf::ancestors
                  (no help text available)
    perf::ancestorset
                  (no help text available)
    perf::annotate
                  (no help text available)
    perf::bdiff   benchmark a bdiff between revisions
    perf::bookmarks
                  benchmark parsing bookmarks from disk to memory
    perf::branchmap
                  benchmark the update of a branchmap
    perf::branchmapload
                  benchmark reading the branchmap
    perf::branchmapupdate
                  benchmark branchmap update from for <base> revs to <target>
                  revs
    perf::bundle  benchmark the creation of a bundle from a repository
    perf::bundleread
                  Benchmark reading of bundle files.
    perf::cca     (no help text available)
    perf::changegroupchangelog
                  Benchmark producing a changelog group for a changegroup.
    perf::changeset
                  (no help text available)
    perf::ctxfiles
                  (no help text available)
    perf::delta-find
                  benchmark the process of finding a valid delta for a revlog
                  revision
    perf::diffwd  Profile diff of working directory changes
    perf::dirfoldmap
                  benchmap a 'dirstate._map.dirfoldmap.get()' request
    perf::dirs    (no help text available)
    perf::dirstate
                  benchmap the time of various distate operations
    perf::dirstatedirs
                  benchmap a 'dirstate.hasdir' call from an empty 'dirs' cache
    perf::dirstatefoldmap
                  benchmap a 'dirstate._map.filefoldmap.get()' request
    perf::dirstatewrite
                  benchmap the time it take to write a dirstate on disk
    perf::discovery
                  benchmark discovery between local repo and the peer at given
                  path
    perf::fncacheencode
                  (no help text available)
    perf::fncacheload
                  (no help text available)
    perf::fncachewrite
                  (no help text available)
    perf::heads   benchmark the computation of a changelog heads
    perf::helper-mergecopies
                  find statistics about potential parameters for
                  'perfmergecopies'
    perf::helper-pathcopies
                  find statistic about potential parameters for the
                  'perftracecopies'
    perf::ignore  benchmark operation related to computing ignore
    perf::index   benchmark index creation time followed by a lookup
    perf::linelogedits
                  (no help text available)
    perf::loadmarkers
                  benchmark the time to parse the on-disk markers for a repo
    perf::log     (no help text available)
    perf::lookup  (no help text available)
    perf::lrucachedict
                  (no help text available)
    perf::manifest
                  benchmark the time to read a manifest from disk and return a
                  usable
    perf::mergecalculate
                  (no help text available)
    perf::mergecopies
                  measure runtime of 'copies.mergecopies'
    perf::moonwalk
                  benchmark walking the changelog backwards
    perf::nodelookup
                  (no help text available)
    perf::nodemap
                  benchmark the time necessary to look up revision from a cold
                  nodemap
    perf::parents
                  benchmark the time necessary to fetch one changeset's parents.
    perf::pathcopies
                  benchmark the copy tracing logic
    perf::phases  benchmark phasesets computation
    perf::phasesremote
                  benchmark time needed to analyse phases of the remote server
    perf::progress
                  printing of progress bars
    perf::rawfiles
                  (no help text available)
    perf::revlogchunks
                  Benchmark operations on revlog chunks.
    perf::revlogindex
                  Benchmark operations against a revlog index.
    perf::revlogrevision
                  Benchmark obtaining a revlog revision.
    perf::revlogrevisions
                  Benchmark reading a series of revisions from a revlog.
    perf::revlogwrite
                  Benchmark writing a series of revisions to a revlog.
    perf::revrange
                  (no help text available)
    perf::revset  benchmark the execution time of a revset
    perf::startup
                  (no help text available)
    perf::status  benchmark the performance of a single status call
    perf::stream-consume
                  benchmark the full application of a stream clone
    perf::stream-generate
                  benchmark the full generation of a stream clone
    perf::stream-locked-section
                  benchmark the initial, repo-locked, section of a stream-clone
-   perf::tags    (no help text available)
+   perf::tags    Benchmark tags retrieval in various situation
    perf::templating
                  test the rendering time of a given template
    perf::unbundle
                  benchmark application of a bundle in a repository.
    perf::unidiff
                  benchmark a unified diff between revisions
    perf::volatilesets
                  benchmark the computation of various volatile set
    perf::walk    (no help text available)
    perf::write   microbenchmark ui.write (and others)
   
   (use 'hg help -v perf' to show built-in aliases and global options)
 
   $ hg help perfaddremove
   hg perf::addremove
   
   aliases: perfaddremove
   
   (no help text available)
   
   options:
   
    -T --template TEMPLATE display with template
   
   (some details hidden, use --verbose to show complete help)
 
   $ hg perfaddremove
   $ hg perfancestors
   $ hg perfancestorset 2
   $ hg perfannotate a
   $ hg perfbdiff -c 1
   $ hg perfbdiff --alldata 1
   $ hg perfunidiff -c 1
   $ hg perfunidiff --alldata 1
   $ hg perfbookmarks
   $ hg perfbranchmap
   $ hg perfbranchmapload
   $ hg perfbranchmapupdate --base "not tip" --target "tip"
   benchmark of branchmap with 3 revisions with 1 new ones
   $ hg perfcca
   $ hg perfchangegroupchangelog
   $ hg perfchangegroupchangelog --cgversion 01
   $ hg perfchangeset 2
   $ hg perfctxfiles 2
   $ hg perfdiffwd
   $ hg perfdirfoldmap
   $ hg perfdirs
   $ hg perfdirstate
   $ hg perfdirstate --contains
   $ hg perfdirstate --iteration
   $ hg perfdirstatedirs
   $ hg perfdirstatefoldmap
   $ hg perfdirstatewrite
 #if repofncache
   $ hg perffncacheencode
   $ hg perffncacheload
   $ hg debugrebuildfncache
   fncache already up to date
   $ hg perffncachewrite
   $ hg debugrebuildfncache
   fncache already up to date
 #endif
   $ hg perfheads
   $ hg perfignore
   $ hg perfindex
   $ hg perflinelogedits -n 1
   $ hg perfloadmarkers
   $ hg perflog
   $ hg perflookup 2
   $ hg perflrucache
   $ hg perfmanifest 2
   $ hg perfmanifest -m 44fe2c8352bb3a478ffd7d8350bbc721920134d1
   $ hg perfmanifest -m 44fe2c8352bb
   abort: manifest revision must be integer or full node
   [255]
   $ hg perfmergecalculate -r 3
   $ hg perfmoonwalk
   $ hg perfnodelookup 2
   $ hg perfpathcopies 1 2
   $ hg perfprogress --total 1000
   $ hg perfrawfiles 2
   $ hg perfrevlogindex -c
 #if reporevlogstore
   $ hg perfrevlogrevisions .hg/store/data/a.i
 #endif
   $ hg perfrevlogrevision -m 0
   $ hg perfrevlogchunks -c
   $ hg perfrevrange
   $ hg perfrevset 'all()'
   $ hg perfstartup
   $ hg perfstatus
   $ hg perfstatus --dirstate
   $ hg perftags
   $ hg perftemplating
   $ hg perfvolatilesets
   $ hg perfwalk
   $ hg perfparents
   $ hg perfdiscovery -q .
 
 Test run control
 ----------------
 
 Simple single entry
 
   $ hg perfparents --config perf.stub=no --config perf.run-limits='0.000000001-15'
   ! wall * comb * user * sys * (best of 15) (glob)
   ! wall * comb * user * sys * (max of 15) (glob)
   ! wall * comb * user * sys * (avg of 15) (glob)
   ! wall * comb * user * sys * (median of 15) (glob)
 
 Multiple entries
 
   $ hg perfparents --config perf.stub=no --config perf.run-limits='500000-1, 0.000000001-50'
   ! wall * comb * user * sys * (best of 50) (glob)
   ! wall * comb * user * sys 0.000000 (max of 50) (glob)
   ! wall * comb * user * sys 0.000000 (avg of 50) (glob)
   ! wall * comb * user * sys 0.000000 (median of 50) (glob)
 
 error case are ignored
 
   $ hg perfparents --config perf.stub=no --config perf.run-limits='500, 0.000000001-50'
   malformatted run limit entry, missing "-": 500
   ! wall * comb * user * sys * (best of 50) (glob)
   ! wall * comb * user * sys * (max of 50) (glob)
   ! wall * comb * user * sys * (avg of 50) (glob)
   ! wall * comb * user * sys * (median of 50) (glob)
   $ hg perfparents --config perf.stub=no --config perf.run-limits='aaa-120, 0.000000001-50'
   malformatted run limit entry, could not convert string to float: 'aaa': aaa-120
   ! wall * comb * user * sys * (best of 50) (glob)
   ! wall * comb * user * sys * (max of 50) (glob)
   ! wall * comb * user * sys * (avg of 50) (glob)
   ! wall * comb * user * sys * (median of 50) (glob)
   $ hg perfparents --config perf.stub=no --config perf.run-limits='120-aaaaaa, 0.000000001-50'
   malformatted run limit entry, invalid literal for int() with base 10: 'aaaaaa': 120-aaaaaa
   ! wall * comb * user * sys * (best of 50) (glob)
   ! wall * comb * user * sys * (max of 50) (glob)
   ! wall * comb * user * sys * (avg of 50) (glob)
   ! wall * comb * user * sys * (median of 50) (glob)
 
 test actual output
 ------------------
 
 normal output:
 
   $ hg perfheads --config perf.stub=no
   ! wall * comb * user * sys * (best of *) (glob)
   ! wall * comb * user * sys * (max of *) (glob)
   ! wall * comb * user * sys * (avg of *) (glob)
   ! wall * comb * user * sys * (median of *) (glob)
 
 detailed output:
 
   $ hg perfheads --config perf.all-timing=yes --config perf.stub=no
   ! wall * comb * user * sys * (best of *) (glob)
   ! wall * comb * user * sys * (max of *) (glob)
   ! wall * comb * user * sys * (avg of *) (glob)
   ! wall * comb * user * sys * (median of *) (glob)
 
 test json output
 ----------------
 
 normal output:
 
   $ hg perfheads --template json --config perf.stub=no
   [
    {
     "avg.comb": *, (glob)
     "avg.count": *, (glob)
     "avg.sys": *, (glob)
     "avg.user": *, (glob)
     "avg.wall": *, (glob)
     "comb": *, (glob)
     "count": *, (glob)
     "max.comb": *, (glob)
     "max.count": *, (glob)
     "max.sys": *, (glob)
     "max.user": *, (glob)
     "max.wall": *, (glob)
     "median.comb": *, (glob)
     "median.count": *, (glob)
     "median.sys": *, (glob)
     "median.user": *, (glob)
     "median.wall": *, (glob)
     "sys": *, (glob)
     "user": *, (glob)
     "wall": * (glob)
    }
   ]
 
 detailed output:
 
   $ hg perfheads --template json --config perf.all-timing=yes --config perf.stub=no
   [
    {
     "avg.comb": *, (glob)
     "avg.count": *, (glob)
     "avg.sys": *, (glob)
     "avg.user": *, (glob)
     "avg.wall": *, (glob)
     "comb": *, (glob)
     "count": *, (glob)
     "max.comb": *, (glob)
     "max.count": *, (glob)
     "max.sys": *, (glob)
     "max.user": *, (glob)
     "max.wall": *, (glob)
     "median.comb": *, (glob)
     "median.count": *, (glob)
     "median.sys": *, (glob)
     "median.user": *, (glob)
     "median.wall": *, (glob)
     "sys": *, (glob)
     "user": *, (glob)
     "wall": * (glob)
    }
   ]
 
 Test pre-run feature
 --------------------
 
 (perf discovery has some spurious output)
 
   $ hg perfdiscovery . --config perf.stub=no --config perf.run-limits='0.000000001-1' --config perf.pre-run=0
   ! wall * comb * user * sys * (best of 1) (glob)
   ! wall * comb * user * sys * (max of 1) (glob)
   ! wall * comb * user * sys * (avg of 1) (glob)
   ! wall * comb * user * sys * (median of 1) (glob)
   searching for changes
   $ hg perfdiscovery . --config perf.stub=no --config perf.run-limits='0.000000001-1' --config perf.pre-run=1
   ! wall * comb * user * sys * (best of 1) (glob)
   ! wall * comb * user * sys * (max of 1) (glob)
   ! wall * comb * user * sys * (avg of 1) (glob)
   ! wall * comb * user * sys * (median of 1) (glob)
   searching for changes
   searching for changes
   $ hg perfdiscovery . --config perf.stub=no --config perf.run-limits='0.000000001-1' --config perf.pre-run=3
   ! wall * comb * user * sys * (best of 1) (glob)
   ! wall * comb * user * sys * (max of 1) (glob)
   ! wall * comb * user * sys * (avg of 1) (glob)
   ! wall * comb * user * sys * (median of 1) (glob)
   searching for changes
   searching for changes
   searching for changes
   searching for changes
   $ hg perf::bundle 'last(all(), 5)'
   $ hg bundle --exact --rev 'last(all(), 5)' last-5.hg
   4 changesets found
   $ hg perf::unbundle last-5.hg
 
 
 test  profile-benchmark option
 ------------------------------
 
 Function to check that statprof ran
   $ statprofran () {
   >   grep -E 'Sample count:|No samples recorded' > /dev/null
   > }
   $ hg perfdiscovery . --config perf.stub=no --config perf.run-limits='0.000000001-1' --config perf.profile-benchmark=yes 2>&1 | statprofran
 
 Check perf.py for historical portability
 ----------------------------------------
 
   $ cd "$TESTDIR/.."
 
   $ (testrepohg files -r 1.2 glob:mercurial/*.c glob:mercurial/*.py;
   >  testrepohg files -r tip glob:mercurial/*.c glob:mercurial/*.py) |
   > "$TESTDIR"/check-perf-code.py contrib/perf.py
   contrib/perf.py:\d+: (re)
    >     from mercurial import (
    import newer module separately in try clause for early Mercurial
   contrib/perf.py:\d+: (re)
    >     from mercurial import (
    import newer module separately in try clause for early Mercurial
   contrib/perf.py:\d+: (re)
    >     origindexpath = orig.opener.join(indexfile)
    use getvfs()/getsvfs() for early Mercurial
   contrib/perf.py:\d+: (re)
    >     origdatapath = orig.opener.join(datafile)
    use getvfs()/getsvfs() for early Mercurial
   contrib/perf.py:\d+: (re)
    >         vfs = vfsmod.vfs(tmpdir)
    use getvfs()/getsvfs() for early Mercurial
   contrib/perf.py:\d+: (re)
    >         vfs.options = getattr(orig.opener, 'options', None)
    use getvfs()/getsvfs() for early Mercurial
   [1]

tests/test-remotefilelog-gc.t

@@ -1,116 +1,111 b''
 #require no-windows
 
   $ . "$TESTDIR/remotefilelog-library.sh"
 
   $ hg init master
   $ cd master
   $ cat >> .hg/hgrc <<EOF
   > [remotefilelog]
   > server=True
   > serverexpiration=-1
   > EOF
   $ echo x > x
   $ hg commit -qAm x
   $ cd ..
 
   $ hgcloneshallow ssh://user@dummy/master shallow -q
   1 files fetched over 1 fetches - (1 misses, 0.00% hit ratio) over *s (glob)
 
 # Set the prefetchdays config to zero so that all commits are prefetched
 # no matter what their creation date is.
   $ cd shallow
   $ cat >> .hg/hgrc <<EOF
   > [remotefilelog]
   > prefetchdays=0
   > EOF
   $ cd ..
 
 # commit a new version of x so we can gc the old one
 
   $ cd master
   $ echo y > x
   $ hg commit -qAm y
   $ cd ..
 
   $ cd shallow
   $ hg pull -q
   $ hg update -q
   1 files fetched over 1 fetches - (1 misses, 0.00% hit ratio) over *s (glob)
   $ cd ..
 
 # gc client cache
 
   $ lastweek=`"$PYTHON" -c 'import datetime,time; print(datetime.datetime.fromtimestamp(time.time() - (86400 * 7)).strftime("%y%m%d%H%M"))'`
   $ find $CACHEDIR -type f -exec touch -t $lastweek {} \;
 
   $ find $CACHEDIR -type f | sort
   $TESTTMP/hgcache/master/11/f6ad8ec52a2984abaafd7c3b516503785c2072/1406e74118627694268417491f018a4a883152f0 (glob)
   $TESTTMP/hgcache/master/11/f6ad8ec52a2984abaafd7c3b516503785c2072/48023ec064c1d522f0d792a5a912bb1bf7859a4a (glob)
   $TESTTMP/hgcache/repos (glob)
   $ hg gc
   finished: removed 1 of 2 files (0.00 GB to 0.00 GB)
   $ find $CACHEDIR -type f | sort
   $TESTTMP/hgcache/master/11/f6ad8ec52a2984abaafd7c3b516503785c2072/48023ec064c1d522f0d792a5a912bb1bf7859a4a (glob)
   $TESTTMP/hgcache/repos
 
 # gc server cache
 
   $ find master/.hg/remotefilelogcache -type f | sort
   master/.hg/remotefilelogcache/x/1406e74118627694268417491f018a4a883152f0 (glob)
   master/.hg/remotefilelogcache/x/48023ec064c1d522f0d792a5a912bb1bf7859a4a (glob)
   $ hg gc master
   finished: removed 0 of 1 files (0.00 GB to 0.00 GB)
   $ find master/.hg/remotefilelogcache -type f | sort
   master/.hg/remotefilelogcache/x/48023ec064c1d522f0d792a5a912bb1bf7859a4a (glob)
 
 # Test that GC keepset includes pullprefetch revset if it is configured
 
   $ cd shallow
   $ cat >> .hg/hgrc <<EOF
   > [remotefilelog]
   > pullprefetch=all()
   > EOF
   $ hg prefetch
   1 files fetched over 1 fetches - (1 misses, 0.00% hit ratio) over *s (glob)
 
   $ cd ..
   $ hg gc
   finished: removed 0 of 2 files (0.00 GB to 0.00 GB)
 
 # Ensure that there are 2 versions of the file in cache
   $ find $CACHEDIR -type f | sort
   $TESTTMP/hgcache/master/11/f6ad8ec52a2984abaafd7c3b516503785c2072/1406e74118627694268417491f018a4a883152f0 (glob)
   $TESTTMP/hgcache/master/11/f6ad8ec52a2984abaafd7c3b516503785c2072/48023ec064c1d522f0d792a5a912bb1bf7859a4a (glob)
   $TESTTMP/hgcache/repos (glob)
 
 # Test that if garbage collection on repack and repack on hg gc flags are set then incremental repack with garbage collector is run
 
   $ hg gc --config remotefilelog.gcrepack=True --config remotefilelog.repackonhggc=True
 
 # Ensure that loose files are repacked
   $ find $CACHEDIR -type f | sort
   $TESTTMP/hgcache/master/packs/320dab99b7e3f60512b97f347689625263d22cf5.dataidx
   $TESTTMP/hgcache/master/packs/320dab99b7e3f60512b97f347689625263d22cf5.datapack
   $TESTTMP/hgcache/master/packs/837b83c1ef6485a336eb4421ac5973c0ec130fbb.histidx
   $TESTTMP/hgcache/master/packs/837b83c1ef6485a336eb4421ac5973c0ec130fbb.histpack
   $TESTTMP/hgcache/repos
 
 # Test that warning is displayed when there are no valid repos in repofile
 
   $ cp $CACHEDIR/repos $CACHEDIR/repos.bak
   $ echo " " > $CACHEDIR/repos
   $ hg gc
   warning: no valid repos in repofile
   $ mv $CACHEDIR/repos.bak $CACHEDIR/repos
 
 # Test that warning is displayed when the repo path is malformed
 
   $ printf "asdas\0das" >> $CACHEDIR/repos
-#if py311
-  $ hg gc
-  finished: removed 0 of 4 files (0.00 GB to 0.00 GB)
-#else
   $ hg gc
   abort: invalid path asdas\x00da: .*(null|NULL).* (re)
   [255]
-#endif

tests/test-rhg.t

@@ -1,420 +1,427 b''
 #require rhg
 
   $ NO_FALLBACK="env RHG_ON_UNSUPPORTED=abort"
 
 Unimplemented command
   $ $NO_FALLBACK rhg unimplemented-command
   unsupported feature: error: The subcommand 'unimplemented-command' wasn't recognized
   
   Usage: rhg [OPTIONS] <COMMAND>
   
   For more information try '--help'
   
   [252]
   $ rhg unimplemented-command --config rhg.on-unsupported=abort-silent
   [252]
 
 Finding root
   $ $NO_FALLBACK rhg root
   abort: no repository found in '$TESTTMP' (.hg not found)!
   [255]
 
   $ hg init repository
   $ cd repository
   $ $NO_FALLBACK rhg root
   $TESTTMP/repository
 
 Reading and setting configuration
   $ echo "[ui]" >> $HGRCPATH
   $ echo "username = user1" >> $HGRCPATH
+  $ echo "[extensions]" >> $HGRCPATH
+  $ echo "sparse =" >> $HGRCPATH
   $ $NO_FALLBACK rhg config ui.username
   user1
   $ echo "[ui]" >> .hg/hgrc
   $ echo "username = user2" >> .hg/hgrc
   $ $NO_FALLBACK rhg config ui.username
   user2
   $ $NO_FALLBACK rhg --config ui.username=user3 config ui.username
   user3
 
 Unwritable file descriptor
   $ $NO_FALLBACK rhg root > /dev/full
   abort: No space left on device (os error 28)
   [255]
 
 Deleted repository
   $ rm -rf `pwd`
   $ $NO_FALLBACK rhg root
   abort: error getting current working directory: $ENOENT$
   [255]
 
 Listing tracked files
   $ cd $TESTTMP
   $ hg init repository
   $ cd repository
   $ for i in 1 2 3; do
   >   echo $i >> file$i
   >   hg add file$i
   > done
   > hg commit -m "commit $i" -q
 
 Listing tracked files from root
   $ $NO_FALLBACK rhg files
   file1
   file2
   file3
 
 Listing tracked files from subdirectory
   $ mkdir -p path/to/directory
   $ cd path/to/directory
   $ $NO_FALLBACK rhg files
   ../../../file1
   ../../../file2
   ../../../file3
 
   $ $NO_FALLBACK rhg files --config ui.relative-paths=legacy
   ../../../file1
   ../../../file2
   ../../../file3
 
   $ $NO_FALLBACK rhg files --config ui.relative-paths=false
   file1
   file2
   file3
 
   $ $NO_FALLBACK rhg files --config ui.relative-paths=true
   ../../../file1
   ../../../file2
   ../../../file3
 
 Listing tracked files through broken pipe
   $ $NO_FALLBACK rhg files | head -n 1
   ../../../file1
 
 Debuging data in inline index
   $ cd $TESTTMP
   $ rm -rf repository
   $ hg init repository
   $ cd repository
   $ for i in 1 2 3 4 5 6; do
   >   echo $i >> file-$i
   >   hg add file-$i
   >   hg commit -m "Commit $i" -q
   > done
   $ $NO_FALLBACK rhg debugdata -c 2
   8d0267cb034247ebfa5ee58ce59e22e57a492297
   test
   0 0
   file-3
   
   Commit 3 (no-eol)
   $ $NO_FALLBACK rhg debugdata -m 2
   file-1\x00b8e02f6433738021a065f94175c7cd23db5f05be (esc)
   file-2\x005d9299349fc01ddd25d0070d149b124d8f10411e (esc)
   file-3\x002661d26c649684b482d10f91960cc3db683c38b4 (esc)
 
 Debuging with full node id
   $ $NO_FALLBACK rhg debugdata -c `hg log -r 0 -T '{node}'`
   d1d1c679d3053e8926061b6f45ca52009f011e3f
   test
   0 0
   file-1
   
   Commit 1 (no-eol)
 
 Specifying revisions by changeset ID
   $ hg log -T '{node}\n'
   c6ad58c44207b6ff8a4fbbca7045a5edaa7e908b
   d654274993d0149eecc3cc03214f598320211900
   f646af7e96481d3a5470b695cf30ad8e3ab6c575
   cf8b83f14ead62b374b6e91a0e9303b85dfd9ed7
   91c6f6e73e39318534dc415ea4e8a09c99cd74d6
   6ae9681c6d30389694d8701faf24b583cf3ccafe
   $ $NO_FALLBACK rhg files -r cf8b83
   file-1
   file-2
   file-3
   $ $NO_FALLBACK rhg cat -r cf8b83 file-2
   2
   $ $NO_FALLBACK rhg cat --rev cf8b83 file-2
   2
   $ $NO_FALLBACK rhg cat -r c file-2
   abort: ambiguous revision identifier: c
   [255]
   $ $NO_FALLBACK rhg cat -r d file-2
   2
   $ $NO_FALLBACK rhg cat -r 0000 file-2
   file-2: no such file in rev 000000000000
   [1]
 
 Cat files
   $ cd $TESTTMP
   $ rm -rf repository
   $ hg init repository
   $ cd repository
   $ echo "original content" > original
   $ hg add original
   $ hg commit -m "add original" original
 Without `--rev`
   $ $NO_FALLBACK rhg cat original
   original content
 With `--rev`
   $ $NO_FALLBACK rhg cat -r 0 original
   original content
 Cat copied file should not display copy metadata
   $ hg copy original copy_of_original
   $ hg commit -m "add copy of original"
   $ $NO_FALLBACK rhg cat original
   original content
   $ $NO_FALLBACK rhg cat -r 1 copy_of_original
   original content
 
 
 Fallback to Python
   $ $NO_FALLBACK rhg cat original --exclude="*.rs"
   unsupported feature: error: Found argument '--exclude' which wasn't expected, or isn't valid in this context
   
     If you tried to supply '--exclude' as a value rather than a flag, use '-- --exclude'
   
   Usage: rhg cat <FILE>...
   
   For more information try '--help'
   
   [252]
   $ rhg cat original --exclude="*.rs"
   original content
 
 Check that `fallback-immediately` overrides `$NO_FALLBACK`
   $ $NO_FALLBACK rhg cat original --exclude="*.rs" --config rhg.fallback-immediately=1
   original content
 
   $ (unset RHG_FALLBACK_EXECUTABLE; rhg cat original --exclude="*.rs")
   abort: 'rhg.on-unsupported=fallback' without 'rhg.fallback-executable' set.
   [255]
 
   $ (unset RHG_FALLBACK_EXECUTABLE; rhg cat original)
   original content
 
   $ rhg cat original --exclude="*.rs" --config rhg.fallback-executable=false
   [1]
 
   $ rhg cat original --exclude="*.rs" --config rhg.fallback-executable=hg-non-existent
   abort: invalid fallback 'hg-non-existent': cannot find binary path
   [253]
 
   $ rhg cat original --exclude="*.rs" --config rhg.fallback-executable=rhg
   Blocking recursive fallback. The 'rhg.fallback-executable = rhg' config points to `rhg` itself.
   unsupported feature: error: Found argument '--exclude' which wasn't expected, or isn't valid in this context
   
     If you tried to supply '--exclude' as a value rather than a flag, use '-- --exclude'
   
   Usage: rhg cat <FILE>...
   
   For more information try '--help'
   
   [252]
 
 Fallback with shell path segments
   $ $NO_FALLBACK rhg cat .
   unsupported feature: `..` or `.` path segment
   [252]
   $ $NO_FALLBACK rhg cat ..
   unsupported feature: `..` or `.` path segment
   [252]
   $ $NO_FALLBACK rhg cat ../..
   unsupported feature: `..` or `.` path segment
   [252]
 
 Fallback with filesets
   $ $NO_FALLBACK rhg cat "set:c or b"
   unsupported feature: fileset
   [252]
 
 Fallback with generic hooks
   $ $NO_FALLBACK rhg cat original --config hooks.pre-cat=something
   unsupported feature: pre-cat hook defined
   [252]
 
   $ $NO_FALLBACK rhg cat original --config hooks.post-cat=something
   unsupported feature: post-cat hook defined
   [252]
 
   $ $NO_FALLBACK rhg cat original --config hooks.fail-cat=something
   unsupported feature: fail-cat hook defined
   [252]
 
 Fallback with [defaults]
   $ $NO_FALLBACK rhg cat original --config "defaults.cat=-r null"
   unsupported feature: `defaults` config set
   [252]
 
 
 Requirements
   $ $NO_FALLBACK rhg debugrequirements
   dotencode
   fncache
   generaldelta
   persistent-nodemap
   revlog-compression-zstd (zstd !)
   revlogv1
   share-safe
   sparserevlog
   store
 
   $ echo indoor-pool >> .hg/requires
   $ $NO_FALLBACK rhg files
   unsupported feature: repository requires feature unknown to this Mercurial: indoor-pool
   [252]
 
   $ $NO_FALLBACK rhg cat -r 1 copy_of_original
   unsupported feature: repository requires feature unknown to this Mercurial: indoor-pool
   [252]
 
   $ $NO_FALLBACK rhg debugrequirements
   unsupported feature: repository requires feature unknown to this Mercurial: indoor-pool
   [252]
 
   $ echo -e '\xFF' >> .hg/requires
   $ $NO_FALLBACK rhg debugrequirements
   abort: parse error in 'requires' file
   [255]
 
 Persistent nodemap
   $ cd $TESTTMP
   $ rm -rf repository
   $ hg --config format.use-persistent-nodemap=no init repository
   $ cd repository
   $ $NO_FALLBACK rhg debugrequirements | grep nodemap
   [1]
   $ hg debugbuilddag .+5000 --overwritten-file --config "storage.revlog.nodemap.mode=warn"
   $ hg id -r tip
   c3ae8dec9fad tip
   $ ls .hg/store/00changelog*
   .hg/store/00changelog.d
   .hg/store/00changelog.i
   $ $NO_FALLBACK rhg files -r c3ae8dec9fad
   of
 
   $ cd $TESTTMP
   $ rm -rf repository
   $ hg --config format.use-persistent-nodemap=True init repository
   $ cd repository
   $ $NO_FALLBACK rhg debugrequirements | grep nodemap
   persistent-nodemap
   $ hg debugbuilddag .+5000 --overwritten-file --config "storage.revlog.nodemap.mode=warn"
   $ hg id -r tip
   c3ae8dec9fad tip
   $ ls .hg/store/00changelog*
   .hg/store/00changelog-*.nd (glob)
   .hg/store/00changelog.d
   .hg/store/00changelog.i
   .hg/store/00changelog.n
 
+Rhg status on a sparse repo with nodemap (this specific combination used to crash in 6.5.2)
+
+  $ hg debugsparse -X excluded-dir
+  $ $NO_FALLBACK rhg status
+
 Specifying revisions by changeset ID
   $ $NO_FALLBACK rhg files -r c3ae8dec9fad
   of
   $ $NO_FALLBACK rhg cat -r c3ae8dec9fad of
   r5000
 
 Crate a shared repository
 
   $ echo "[extensions]"      >> $HGRCPATH
   $ echo "share = "          >> $HGRCPATH
 
   $ cd $TESTTMP
   $ hg init repo1
   $ echo a > repo1/a
   $ hg -R repo1 commit -A -m'init'
   adding a
 
   $ hg share repo1 repo2
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 And check that basic rhg commands work with sharing
 
   $ $NO_FALLBACK rhg files -R repo2
   repo2/a
   $ $NO_FALLBACK rhg -R repo2 cat -r 0 repo2/a
   a
 
 Same with relative sharing
 
   $ hg share repo2 repo3 --relative
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ $NO_FALLBACK rhg files -R repo3
   repo3/a
   $ $NO_FALLBACK rhg -R repo3 cat -r 0 repo3/a
   a
 
 Same with share-safe
 
   $ echo "[format]"         >> $HGRCPATH
   $ echo "use-share-safe = True" >> $HGRCPATH
 
   $ cd $TESTTMP
   $ hg init repo4
   $ cd repo4
   $ echo a > a
   $ hg commit -A -m'init'
   adding a
 
   $ cd ..
   $ hg share repo4 repo5
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 And check that basic rhg commands work with sharing
 
   $ cd repo5
   $ $NO_FALLBACK rhg files
   a
   $ $NO_FALLBACK rhg cat -r 0 a
   a
 
 The blackbox extension is supported
 
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "blackbox =" >> $HGRCPATH
   $ echo "[blackbox]" >> $HGRCPATH
   $ echo "maxsize = 1" >> $HGRCPATH
   $ $NO_FALLBACK rhg files > /dev/null
   $ cat .hg/blackbox.log
   ????-??-?? ??:??:??.??? * @d3873e73d99ef67873dac33fbcc66268d5d2b6f4 (*)> (rust) files exited 0 after * seconds (glob)
   $ cat .hg/blackbox.log.1
   ????-??-?? ??:??:??.??? * @d3873e73d99ef67873dac33fbcc66268d5d2b6f4 (*)> (rust) files (glob)
 
 Subrepos are not supported
 
   $ touch .hgsub
   $ $NO_FALLBACK rhg files
   unsupported feature: subrepos (.hgsub is present)
   [252]
   $ rhg files
   a
   $ rm .hgsub
 
 The `:required` extension suboptions are correctly ignored
 
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "blackbox:required = yes" >> $HGRCPATH
   $ rhg files
   a
   $ echo "*:required = yes" >> $HGRCPATH
   $ rhg files
   a
 
 We can ignore all extensions at once
 
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "thisextensionbetternotexist=" >> $HGRCPATH
   $ echo "thisextensionbetternotexisteither=" >> $HGRCPATH
   $ $NO_FALLBACK rhg files
   unsupported feature: extensions: thisextensionbetternotexist, thisextensionbetternotexisteither (consider adding them to 'rhg.ignored-extensions' config)
   [252]
 
   $ echo "[rhg]" >> $HGRCPATH
   $ echo "ignored-extensions=*" >> $HGRCPATH
   $ $NO_FALLBACK rhg files
   a

tests/test-share-safe.t

@@ -1,655 +1,655 b''
 setup
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > share =
   > [format]
   > use-share-safe = True
   > [storage]
   > revlog.persistent-nodemap.slow-path=allow
   > # enforce zlib to ensure we can upgrade to zstd later
   > [format]
   > revlog-compression=zlib
   > # we want to be able to enable it later
   > use-persistent-nodemap=no
   > EOF
 
 prepare source repo
 
   $ hg init source
   $ cd source
   $ cat .hg/requires
   dirstate-v2 (dirstate-v2 !)
   share-safe
   $ cat .hg/store/requires
   dotencode
   fncache
   generaldelta
   revlogv1
   sparserevlog
   store
   $ hg debugrequirements
   dotencode
   dirstate-v2 (dirstate-v2 !)
   fncache
   generaldelta
   revlogv1
   share-safe
   sparserevlog
   store
 
   $ echo a > a
   $ hg ci -Aqm "added a"
   $ echo b > b
   $ hg ci -Aqm "added b"
 
   $ HGEDITOR=cat hg config --shared
   abort: repository is not shared; can't use --shared
   [10]
   $ cd ..
 
 Create a shared repo and check the requirements are shared and read correctly
   $ hg share source shared1
   updating working directory
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd shared1
   $ cat .hg/requires
   dirstate-v2 (dirstate-v2 !)
   share-safe
   shared
 
   $ hg debugrequirements -R ../source
   dotencode
   dirstate-v2 (dirstate-v2 !)
   fncache
   generaldelta
   revlogv1
   share-safe
   sparserevlog
   store
 
   $ hg debugrequirements
   dotencode
   dirstate-v2 (dirstate-v2 !)
   fncache
   generaldelta
   revlogv1
   share-safe
   shared
   sparserevlog
   store
 
   $ echo c > c
   $ hg ci -Aqm "added c"
 
 Check that config of the source repository is also loaded
 
   $ hg showconfig ui.curses
   [1]
 
   $ echo "[ui]" >> ../source/.hg/hgrc
   $ echo "curses=true" >> ../source/.hg/hgrc
 
   $ hg showconfig ui.curses
   true
 
 Test that extensions of source repository are also loaded
 
   $ hg debugextensions
   share
   $ hg extdiff -p echo
   hg: unknown command 'extdiff'
   'extdiff' is provided by the following extension:
   
       extdiff       command to allow external programs to compare revisions
   
   (use 'hg help extensions' for information on enabling extensions)
   [10]
 
   $ echo "[extensions]" >> ../source/.hg/hgrc
   $ echo "extdiff=" >> ../source/.hg/hgrc
 
   $ hg debugextensions -R ../source
   extdiff
   share
   $ hg extdiff -R ../source -p echo
 
 BROKEN: the command below will not work if config of shared source is not loaded
 on dispatch but debugextensions says that extension
 is loaded
   $ hg debugextensions
   extdiff
   share
 
   $ hg extdiff -p echo
 
 However, local .hg/hgrc should override the config set by share source
 
   $ echo "[ui]" >> .hg/hgrc
   $ echo "curses=false" >> .hg/hgrc
 
   $ hg showconfig ui.curses
   false
 
   $ HGEDITOR=cat hg config --shared
   [ui]
   curses=true
   [extensions]
   extdiff=
 
   $ HGEDITOR=cat hg config --local
   [ui]
   curses=false
 
 Testing that hooks set in source repository also runs in shared repo
 
   $ cd ../source
   $ cat <<EOF >> .hg/hgrc
   > [extensions]
   > hooklib=
   > [hooks]
   > pretxnchangegroup.reject_merge_commits = \
   >   python:hgext.hooklib.reject_merge_commits.hook
   > EOF
 
   $ cd ..
   $ hg clone source cloned
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd cloned
   $ hg up 0
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo bar > bar
   $ hg ci -Aqm "added bar"
   $ hg merge
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m "merge commit"
 
   $ hg push ../source
   pushing to ../source
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   error: pretxnchangegroup.reject_merge_commits hook failed: bcde3522682d rejected as merge on the same branch. Please consider rebase.
   transaction abort!
   rollback completed
   abort: bcde3522682d rejected as merge on the same branch. Please consider rebase.
   [255]
 
   $ hg push ../shared1
   pushing to ../shared1
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   error: pretxnchangegroup.reject_merge_commits hook failed: bcde3522682d rejected as merge on the same branch. Please consider rebase.
   transaction abort!
   rollback completed
   abort: bcde3522682d rejected as merge on the same branch. Please consider rebase.
   [255]
 
 Test that if share source config is untrusted, we dont read it
 
   $ cd ../shared1
 
   $ cat << EOF > $TESTTMP/untrusted.py
   > from mercurial import scmutil, util
   > def uisetup(ui):
   >     class untrustedui(ui.__class__):
   >         def _trusted(self, fp, f):
   >             if util.normpath(fp.name).endswith(b'source/.hg/hgrc'):
   >                 return False
   >             return super(untrustedui, self)._trusted(fp, f)
   >     ui.__class__ = untrustedui
   > EOF
 
   $ hg showconfig hooks
   hooks.pretxnchangegroup.reject_merge_commits=python:hgext.hooklib.reject_merge_commits.hook
 
   $ hg showconfig hooks --config extensions.untrusted=$TESTTMP/untrusted.py
   [1]
 
 Update the source repository format and check that shared repo works
 
   $ cd ../source
 
 Disable zstd related tests because its not present on pure version
 #if zstd
   $ echo "[format]" >> .hg/hgrc
   $ echo "revlog-compression=zstd" >> .hg/hgrc
 
   $ hg debugupgraderepo --run -q
   upgrade will perform the following actions:
   
   requirements
      preserved: dotencode, fncache, generaldelta, revlogv1, share-safe, sparserevlog, store (no-dirstate-v2 !)
      preserved: dotencode, use-dirstate-v2, fncache, generaldelta, revlogv1, share-safe, sparserevlog, store (dirstate-v2 !)
      added: revlog-compression-zstd
   
   processed revlogs:
     - all-filelogs
     - changelog
     - manifest
   
   $ hg log -r .
   changeset:   1:5f6d8a4bf34a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     added b
   
 #endif
   $ echo "[format]" >> .hg/hgrc
   $ echo "use-persistent-nodemap=True" >> .hg/hgrc
 
   $ hg debugupgraderepo --run -q -R ../shared1
   abort: cannot use these actions on a share repository: persistent-nodemap
   (upgrade the main repository directly)
   [255]
 
   $ hg debugupgraderepo --run -q
   upgrade will perform the following actions:
   
   requirements
      preserved: dotencode, fncache, generaldelta, revlogv1, share-safe, sparserevlog, store (no-zstd no-dirstate-v2 !)
      preserved: dotencode, fncache, generaldelta, revlog-compression-zstd, revlogv1, share-safe, sparserevlog, store (zstd no-dirstate-v2 !)
      preserved: dotencode, use-dirstate-v2, fncache, generaldelta, revlogv1, share-safe, sparserevlog, store (no-zstd dirstate-v2 !)
      preserved: dotencode, use-dirstate-v2, fncache, generaldelta, revlog-compression-zstd, revlogv1, share-safe, sparserevlog, store (zstd dirstate-v2 !)
      added: persistent-nodemap
   
   processed revlogs:
     - all-filelogs
     - changelog
     - manifest
   
   $ hg log -r .
   changeset:   1:5f6d8a4bf34a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     added b
   
 
 Shared one should work
   $ cd ../shared1
   $ hg log -r .
   changeset:   2:155349b645be
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     added c
   
 
 Testing that nonsharedrc is loaded for source and not shared
 
   $ cd ../source
   $ touch .hg/hgrc-not-shared
   $ echo "[ui]" >> .hg/hgrc-not-shared
   $ echo "traceback=true" >> .hg/hgrc-not-shared
 
   $ hg showconfig ui.traceback
   true
 
   $ HGEDITOR=cat hg config --non-shared
   [ui]
   traceback=true
 
   $ cd ../shared1
   $ hg showconfig ui.traceback
   [1]
 
 Unsharing works
 
   $ hg unshare
 
 Test that source config is added to the shared one after unshare, and the config
 of current repo is still respected over the config which came from source config
   $ cd ../cloned
   $ hg push ../shared1
   pushing to ../shared1
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   error: pretxnchangegroup.reject_merge_commits hook failed: bcde3522682d rejected as merge on the same branch. Please consider rebase.
   transaction abort!
   rollback completed
   abort: bcde3522682d rejected as merge on the same branch. Please consider rebase.
   [255]
   $ hg showconfig ui.curses -R ../shared1
   false
 
   $ cd ../
 
 Test that upgrading using debugupgraderepo works
 =================================================
 
   $ hg init non-share-safe --config format.use-share-safe=false
   $ cd non-share-safe
   $ hg debugrequirements
   dotencode
   dirstate-v2 (dirstate-v2 !)
   fncache
   generaldelta
   revlogv1
   sparserevlog
   store
   $ echo foo > foo
   $ hg ci -Aqm 'added foo'
   $ echo bar > bar
   $ hg ci -Aqm 'added bar'
 
 Create a share before upgrading
 
   $ cd ..
   $ hg share non-share-safe nss-share
   updating working directory
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg debugrequirements -R nss-share
   dotencode
   dirstate-v2 (dirstate-v2 !)
   fncache
   generaldelta
   revlogv1
   shared
   sparserevlog
   store
   $ cd non-share-safe
 
 Upgrade
 
   $ hg debugupgraderepo -q
   requirements
      preserved: dotencode, fncache, generaldelta, revlogv1, sparserevlog, store (no-dirstate-v2 !)
      preserved: dotencode, use-dirstate-v2, fncache, generaldelta, revlogv1, sparserevlog, store (dirstate-v2 !)
      added: share-safe
   
   no revlogs to process
   
   $ hg debugupgraderepo --run
   upgrade will perform the following actions:
   
   requirements
      preserved: dotencode, fncache, generaldelta, revlogv1, sparserevlog, store (no-dirstate-v2 !)
      preserved: dotencode, use-dirstate-v2, fncache, generaldelta, revlogv1, sparserevlog, store (dirstate-v2 !)
      added: share-safe
   
   share-safe
      Upgrades a repository to share-safe format so that future shares of this repository share its requirements and configs.
   
   no revlogs to process
   
   beginning upgrade...
   repository locked and read-only
   creating temporary repository to stage upgraded data: $TESTTMP/non-share-safe/.hg/upgrade.* (glob)
   (it is safe to interrupt this process any time before data migration completes)
   upgrading repository requirements
   removing temporary repository $TESTTMP/non-share-safe/.hg/upgrade.* (glob)
   repository upgraded to share safe mode, existing shares will still work in old non-safe mode. Re-share existing shares to use them in safe mode New shares will be created in safe mode.
 
   $ hg debugrequirements
   dotencode
   dirstate-v2 (dirstate-v2 !)
   fncache
   generaldelta
   revlogv1
   share-safe
   sparserevlog
   store
 
   $ cat .hg/requires
   dirstate-v2 (dirstate-v2 !)
   share-safe
 
   $ cat .hg/store/requires
   dotencode
   fncache
   generaldelta
   revlogv1
   sparserevlog
   store
 
   $ hg log -GT "{node}: {desc}\n"
   @  f63db81e6dde1d9c78814167f77fb1fb49283f4f: added bar
   |
   o  f3ba8b99bb6f897c87bbc1c07b75c6ddf43a4f77: added foo
   
 
 Make sure existing shares dont work with default config
 
   $ hg log -GT "{node}: {desc}\n" -R ../nss-share
   abort: version mismatch: source uses share-safe functionality while the current share does not
   (see `hg help config.format.use-share-safe` for more information)
   [255]
 
 
 Create a safe share from upgrade one
 
   $ cd ..
   $ hg share non-share-safe ss-share
   updating working directory
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ss-share
   $ hg log -GT "{node}: {desc}\n"
   @  f63db81e6dde1d9c78814167f77fb1fb49283f4f: added bar
   |
   o  f3ba8b99bb6f897c87bbc1c07b75c6ddf43a4f77: added foo
   
   $ cd ../non-share-safe
 
 Test that downgrading works too
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > share =
   > [format]
   > use-share-safe = False
   > EOF
 
   $ hg debugupgraderepo -q
   requirements
      preserved: dotencode, fncache, generaldelta, revlogv1, sparserevlog, store (no-dirstate-v2 !)
      preserved: dotencode, use-dirstate-v2, fncache, generaldelta, revlogv1, sparserevlog, store (dirstate-v2 !)
      removed: share-safe
   
   no revlogs to process
   
   $ hg debugupgraderepo --run
   upgrade will perform the following actions:
   
   requirements
      preserved: dotencode, fncache, generaldelta, revlogv1, sparserevlog, store (no-dirstate-v2 !)
      preserved: dotencode, use-dirstate-v2, fncache, generaldelta, revlogv1, sparserevlog, store (dirstate-v2 !)
      removed: share-safe
   
   no revlogs to process
   
   beginning upgrade...
   repository locked and read-only
   creating temporary repository to stage upgraded data: $TESTTMP/non-share-safe/.hg/upgrade.* (glob)
   (it is safe to interrupt this process any time before data migration completes)
   upgrading repository requirements
   removing temporary repository $TESTTMP/non-share-safe/.hg/upgrade.* (glob)
-  repository downgraded to not use share safe mode, existing shares will not work and needs to be reshared.
+  repository downgraded to not use share safe mode, existing shares will not work and need to be reshared.
 
   $ hg debugrequirements
   dotencode
   dirstate-v2 (dirstate-v2 !)
   fncache
   generaldelta
   revlogv1
   sparserevlog
   store
 
   $ cat .hg/requires
   dotencode
   dirstate-v2 (dirstate-v2 !)
   fncache
   generaldelta
   revlogv1
   sparserevlog
   store
 
   $ test -f .hg/store/requires
   [1]
 
   $ hg log -GT "{node}: {desc}\n"
   @  f63db81e6dde1d9c78814167f77fb1fb49283f4f: added bar
   |
   o  f3ba8b99bb6f897c87bbc1c07b75c6ddf43a4f77: added foo
   
 
 Make sure existing shares still works
 
   $ hg log -GT "{node}: {desc}\n" -R ../nss-share
   @  f63db81e6dde1d9c78814167f77fb1fb49283f4f: added bar
   |
   o  f3ba8b99bb6f897c87bbc1c07b75c6ddf43a4f77: added foo
   
 
   $ hg log -GT "{node}: {desc}\n" -R ../ss-share
   abort: share source does not support share-safe requirement
   (see `hg help config.format.use-share-safe` for more information)
   [255]
 
 Testing automatic downgrade of shares when config is set
 
   $ touch ../ss-share/.hg/wlock
   $ hg log -GT "{node}: {desc}\n" -R ../ss-share --config share.safe-mismatch.source-not-safe=downgrade-abort
   abort: failed to downgrade share, got error: Lock held
   (see `hg help config.format.use-share-safe` for more information)
   [255]
   $ rm ../ss-share/.hg/wlock
 
   $ cp -R ../ss-share ../ss-share-bck
   $ hg log -GT "{node}: {desc}\n" -R ../ss-share --config share.safe-mismatch.source-not-safe=downgrade-abort
   repository downgraded to not use share-safe mode
   @  f63db81e6dde1d9c78814167f77fb1fb49283f4f: added bar
   |
   o  f3ba8b99bb6f897c87bbc1c07b75c6ddf43a4f77: added foo
   
   $ rm -rf ../ss-share
   $ mv ../ss-share-bck ../ss-share
 
   $ hg log -GT "{node}: {desc}\n" -R ../ss-share --config share.safe-mismatch.source-not-safe=downgrade-abort --config share.safe-mismatch.source-not-safe:verbose-upgrade=no
   @  f63db81e6dde1d9c78814167f77fb1fb49283f4f: added bar
   |
   o  f3ba8b99bb6f897c87bbc1c07b75c6ddf43a4f77: added foo
   
 
   $ hg log -GT "{node}: {desc}\n" -R ../ss-share
   @  f63db81e6dde1d9c78814167f77fb1fb49283f4f: added bar
   |
   o  f3ba8b99bb6f897c87bbc1c07b75c6ddf43a4f77: added foo
   
 
 
 Testing automatic upgrade of shares when config is set
 
   $ hg debugupgraderepo -q --run --config format.use-share-safe=True
   upgrade will perform the following actions:
   
   requirements
      preserved: dotencode, fncache, generaldelta, revlogv1, sparserevlog, store (no-dirstate-v2 !)
      preserved: dotencode, use-dirstate-v2, fncache, generaldelta, revlogv1, sparserevlog, store (dirstate-v2 !)
      added: share-safe
   
   no revlogs to process
   
   repository upgraded to share safe mode, existing shares will still work in old non-safe mode. Re-share existing shares to use them in safe mode New shares will be created in safe mode.
   $ hg debugrequirements
   dotencode
   dirstate-v2 (dirstate-v2 !)
   fncache
   generaldelta
   revlogv1
   share-safe
   sparserevlog
   store
   $ hg log -GT "{node}: {desc}\n" -R ../nss-share
   abort: version mismatch: source uses share-safe functionality while the current share does not
   (see `hg help config.format.use-share-safe` for more information)
   [255]
 
 Check that if lock is taken, upgrade fails but read operation are successful
   $ hg log -GT "{node}: {desc}\n" -R ../nss-share --config share.safe-mismatch.source-safe=upgra
   abort: share-safe mismatch with source.
   Unrecognized value 'upgra' of `share.safe-mismatch.source-safe` set.
   (see `hg help config.format.use-share-safe` for more information)
   [255]
   $ touch ../nss-share/.hg/wlock
   $ hg log -GT "{node}: {desc}\n" -R ../nss-share --config share.safe-mismatch.source-safe=upgrade-allow
   failed to upgrade share, got error: Lock held
   @  f63db81e6dde1d9c78814167f77fb1fb49283f4f: added bar
   |
   o  f3ba8b99bb6f897c87bbc1c07b75c6ddf43a4f77: added foo
   
 
   $ hg log -GT "{node}: {desc}\n" -R ../nss-share --config share.safe-mismatch.source-safe=upgrade-allow --config share.safe-mismatch.source-safe.warn=False
   @  f63db81e6dde1d9c78814167f77fb1fb49283f4f: added bar
   |
   o  f3ba8b99bb6f897c87bbc1c07b75c6ddf43a4f77: added foo
   
 
   $ hg log -GT "{node}: {desc}\n" -R ../nss-share --config share.safe-mismatch.source-safe=upgrade-abort
   abort: failed to upgrade share, got error: Lock held
   (see `hg help config.format.use-share-safe` for more information)
   [255]
 
   $ rm ../nss-share/.hg/wlock
   $ cp -R ../nss-share ../nss-share-bck
   $ hg log -GT "{node}: {desc}\n" -R ../nss-share --config share.safe-mismatch.source-safe=upgrade-abort
   repository upgraded to use share-safe mode
   @  f63db81e6dde1d9c78814167f77fb1fb49283f4f: added bar
   |
   o  f3ba8b99bb6f897c87bbc1c07b75c6ddf43a4f77: added foo
   
   $ rm -rf ../nss-share
   $ mv ../nss-share-bck ../nss-share
   $ hg log -GT "{node}: {desc}\n" -R ../nss-share --config share.safe-mismatch.source-safe=upgrade-abort --config share.safe-mismatch.source-safe:verbose-upgrade=no
   @  f63db81e6dde1d9c78814167f77fb1fb49283f4f: added bar
   |
   o  f3ba8b99bb6f897c87bbc1c07b75c6ddf43a4f77: added foo
   
 
 Test that unshare works
 
   $ hg unshare -R ../nss-share
   $ hg log -GT "{node}: {desc}\n" -R ../nss-share
   @  f63db81e6dde1d9c78814167f77fb1fb49283f4f: added bar
   |
   o  f3ba8b99bb6f897c87bbc1c07b75c6ddf43a4f77: added foo
   
 
 Test automatique upgrade/downgrade of main-repository
 ------------------------------------------------------
 
 create an initial repository
 
   $ hg init auto-upgrade \
   > --config format.use-share-safe=no
   $ hg debugbuilddag -R auto-upgrade --new-file .+5
   $ hg -R auto-upgrade update
   6 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg debugformat -R auto-upgrade | grep share-safe
   share-safe:          no
 
 upgrade it to share-safe automatically
 
   $ hg status -R auto-upgrade \
   >     --config format.use-share-safe.automatic-upgrade-of-mismatching-repositories=yes \
   >     --config format.use-share-safe=yes
   automatically upgrading repository to the `share-safe` feature
   (see `hg help config.format.use-share-safe` for details)
   $ hg debugformat -R auto-upgrade | grep share-safe
   share-safe:         yes
 
 downgrade it from share-safe automatically
 
   $ hg status -R auto-upgrade \
   >     --config format.use-share-safe.automatic-upgrade-of-mismatching-repositories=yes \
   >     --config format.use-share-safe=no
   automatically downgrading repository from the `share-safe` feature
   (see `hg help config.format.use-share-safe` for details)
   $ hg debugformat -R auto-upgrade | grep share-safe
   share-safe:          no

tests/test-static-http.t

@@ -1,283 +1,300 b''
 #require no-reposimplestore
 
   $ hg clone http://localhost:$HGPORT/ copy
   abort: * (glob)
   [100]
   $ test -d copy
   [1]
 
 This server doesn't do range requests so it's basically only good for
 one pull
 
   $ "$PYTHON" "$TESTDIR/dumbhttp.py" -p $HGPORT --pid dumb.pid \
   > --logfile server.log
   $ cat dumb.pid >> $DAEMON_PIDS
   $ hg init remote
   $ cd remote
   $ echo foo > bar
   $ echo c2 > '.dotfile with spaces'
   $ hg add
   adding .dotfile with spaces
   adding bar
   $ hg commit -m"test"
   $ hg tip
   changeset:   0:02770d679fb8
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     test
   
   $ cd ..
   $ hg clone static-http://localhost:$HGPORT/remote local
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   new changesets 02770d679fb8
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd local
   $ hg verify -q
   $ cat bar
   foo
   $ cd ../remote
   $ echo baz > quux
   $ hg commit -A -mtest2
   adding quux
 
 check for HTTP opener failures when cachefile does not exist
 
   $ rm .hg/cache/*
   $ cd ../local
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > changegroup = sh -c "printenv.py --line changegroup"
   > EOF
   $ hg pull
   pulling from static-http://localhost:$HGPORT/remote
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets 4ac2e3648604
   changegroup hook: HG_HOOKNAME=changegroup
   HG_HOOKTYPE=changegroup
   HG_NODE=4ac2e3648604439c580c69b09ec9d93a88d93432
   HG_NODE_LAST=4ac2e3648604439c580c69b09ec9d93a88d93432
   HG_SOURCE=pull
   HG_TXNID=TXN:$ID$
   HG_TXNNAME=pull
   http://localhost:$HGPORT/remote
   HG_URL=http://localhost:$HGPORT/remote
   
   (run 'hg update' to get a working copy)
 
 trying to push
 
   $ hg update
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo more foo >> bar
   $ hg commit -m"test"
   $ hg push
   pushing to static-http://localhost:$HGPORT/remote
   abort: destination does not support push
   [255]
 
 trying clone -r
 
   $ cd ..
   $ hg clone -r doesnotexist static-http://localhost:$HGPORT/remote local0
   abort: unknown revision 'doesnotexist'
   [10]
   $ hg clone -r 0 static-http://localhost:$HGPORT/remote local0
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   new changesets 02770d679fb8
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 test with "/" URI (issue747) and subrepo
 
   $ hg init
   $ hg init sub
   $ touch sub/test
   $ hg -R sub commit -A -m "test"
   adding test
   $ hg -R sub tag not-empty
   $ echo sub=sub > .hgsub
   $ echo a > a
   $ hg add a .hgsub
   $ hg -q ci -ma
   $ hg clone static-http://localhost:$HGPORT/ local2
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 3 changes to 3 files
   new changesets a9ebfbe8e587
   updating to branch default
   cloning subrepo sub from static-http://localhost:$HGPORT/sub
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   new changesets be090ea66256:322ea90975df
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd local2
   $ hg verify -q
   $ cat a
   a
   $ hg paths
   default = static-http://localhost:$HGPORT/
 
 test with empty repo (issue965)
 
   $ cd ..
   $ hg init remotempty
   $ hg clone static-http://localhost:$HGPORT/remotempty local3
   no changes found
   updating to branch default
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd local3
   $ hg verify -q
   $ hg paths
   default = static-http://localhost:$HGPORT/remotempty
 
+test autodetecting static-http: scheme (issue6833)
+
+  $ cd ..
+  $ hg init actually-static
+  $ hg clone http://localhost:$HGPORT/actually-static local4
+  no changes found
+  updating to branch default
+  0 files updated, 0 files merged, 0 files removed, 0 files unresolved
+
 test with non-repo
 
-  $ cd ..
   $ mkdir notarepo
   $ hg clone static-http://localhost:$HGPORT/notarepo local3
   abort: 'http://localhost:$HGPORT/notarepo' does not appear to be an hg repository
   [255]
 
 Clone with tags and branches works
 
   $ hg init remote-with-names
   $ cd remote-with-names
   $ echo 0 > foo
   $ hg -q commit -A -m initial
   $ echo 1 > foo
   $ hg commit -m 'commit 1'
   $ hg -q up 0
   $ hg branch mybranch
   marked working directory as branch mybranch
   (branches are permanent and global, did you want a bookmark?)
   $ echo 2 > foo
   $ hg commit -m 'commit 2 (mybranch)'
   $ hg tag -r 1 'default-tag'
   $ hg tag -r 2 'branch-tag'
 
   $ cd ..
 
   $ hg clone static-http://localhost:$HGPORT/remote-with-names local-with-names
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 5 changesets with 5 changes to 2 files (+1 heads)
   new changesets 68986213bd44:0c325bd2b5a7
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Clone a specific branch works
 
   $ hg clone -r mybranch static-http://localhost:$HGPORT/remote-with-names local-with-names-branch
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 4 changes to 2 files
   new changesets 68986213bd44:0c325bd2b5a7
   updating to branch mybranch
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Clone a specific tag works
 
   $ hg clone -r default-tag static-http://localhost:$HGPORT/remote-with-names local-with-names-tag
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files
   new changesets 68986213bd44:4ee3fcef1c80
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ killdaemons.py
 
 List of files accessed over HTTP:
 
   $ cat server.log | sed -n -e 's|.*GET \(/[^ ]*\).*|\1|p' | sort -u
   /.hg/bookmarks
   /.hg/bookmarks.current
   /.hg/cache/hgtagsfnodes1
   /.hg/dirstate
   /.hg/requires
   /.hg/store/00changelog.i
   /.hg/store/00manifest.i
   /.hg/store/data/%7E2ehgsub.i (no-py37 !)
   /.hg/store/data/%7E2ehgsubstate.i (no-py37 !)
   /.hg/store/data/a.i
   /.hg/store/data/~2ehgsub.i (py37 !)
   /.hg/store/data/~2ehgsubstate.i (py37 !)
   /.hg/store/requires
+  /actually-static/.hg/bookmarks
+  /actually-static/.hg/bookmarks.current
+  /actually-static/.hg/dirstate
+  /actually-static/.hg/requires
+  /actually-static/.hg/store/00changelog.i
+  /actually-static/.hg/store/00manifest.i
+  /actually-static/.hg/store/requires
+  /actually-static/?cmd=capabilities
+  /actually-static?cmd=capabilities
   /notarepo/.hg/00changelog.i
   /notarepo/.hg/requires
   /remote-with-names/.hg/bookmarks
   /remote-with-names/.hg/bookmarks.current
   /remote-with-names/.hg/cache/branch2-served
   /remote-with-names/.hg/cache/hgtagsfnodes1
   /remote-with-names/.hg/cache/tags2-served
   /remote-with-names/.hg/dirstate
   /remote-with-names/.hg/localtags
   /remote-with-names/.hg/requires
   /remote-with-names/.hg/store/00changelog.i
   /remote-with-names/.hg/store/00manifest.i
   /remote-with-names/.hg/store/data/%7E2ehgtags.i (no-py37 !)
   /remote-with-names/.hg/store/data/foo.i
   /remote-with-names/.hg/store/data/~2ehgtags.i (py37 !)
   /remote-with-names/.hg/store/obsstore
   /remote-with-names/.hg/store/requires
   /remote/.hg/bookmarks
   /remote/.hg/bookmarks.current
   /remote/.hg/cache/branch2-base
   /remote/.hg/cache/branch2-immutable
   /remote/.hg/cache/branch2-served
   /remote/.hg/cache/hgtagsfnodes1
   /remote/.hg/cache/rbc-names-v1
   /remote/.hg/cache/tags2-served
   /remote/.hg/dirstate
   /remote/.hg/localtags
   /remote/.hg/requires
   /remote/.hg/store/00changelog.i
   /remote/.hg/store/00manifest.i
   /remote/.hg/store/data/%7E2edotfile%20with%20spaces.i (no-py37 !)
   /remote/.hg/store/data/%7E2ehgtags.i (no-py37 !)
   /remote/.hg/store/data/bar.i
   /remote/.hg/store/data/quux.i
   /remote/.hg/store/data/~2edotfile%20with%20spaces.i (py37 !)
   /remote/.hg/store/data/~2ehgtags.i (py37 !)
   /remote/.hg/store/obsstore
   /remote/.hg/store/requires
   /remotempty/.hg/bookmarks
   /remotempty/.hg/bookmarks.current
   /remotempty/.hg/dirstate
   /remotempty/.hg/requires
   /remotempty/.hg/store/00changelog.i
   /remotempty/.hg/store/00manifest.i
   /remotempty/.hg/store/requires
   /sub/.hg/bookmarks
   /sub/.hg/bookmarks.current
   /sub/.hg/cache/hgtagsfnodes1
   /sub/.hg/dirstate
   /sub/.hg/requires
   /sub/.hg/store/00changelog.i
   /sub/.hg/store/00manifest.i
   /sub/.hg/store/data/%7E2ehgtags.i (no-py37 !)
   /sub/.hg/store/data/test.i
   /sub/.hg/store/data/~2ehgtags.i (py37 !)
   /sub/.hg/store/requires