clone: reuse the stream clone logic for local clone

Streaming clone and local (non `--pull`) clone do mostly the same thing,
however they were using different logic to do so. This means the logic
frequently went out of sync and that new case had to be dealt with twice.

This is fragile and anoying. So we replace this with a re-use of the logic we
use for streaming clone.

I can see various test changes:

- a more precise progress output,
- armless fncache loading during clone,
- fncache is no longer hardlinked (since we write it by hand).

I am not reinstalling the `reposimplestore` specific output, as far as I
understand this variant have been broken for years.

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

mercurial/hg.py

@@ -1,1599 +1,1590 b''
 # hg.py - repository classes for mercurial
 #
 # Copyright 2005-2007 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.
 
 from __future__ import absolute_import
 
 import errno
 import os
 import shutil
 import stat
 
 from .i18n import _
 from .node import (
     hex,
     sha1nodeconstants,
     short,
 )
 from .pycompat import getattr
 
 from . import (
     bookmarks,
     bundlerepo,
-    cacheutil,
     cmdutil,
     destutil,
     discovery,
     error,
     exchange,
     extensions,
     graphmod,
     httppeer,
     localrepo,
     lock,
     logcmdutil,
     logexchange,
     merge as mergemod,
     mergestate as mergestatemod,
     narrowspec,
     phases,
     requirements,
     scmutil,
     sshpeer,
     statichttprepo,
     ui as uimod,
     unionrepo,
     url,
     util,
     verify as verifymod,
     vfs as vfsmod,
 )
 from .interfaces import repository as repositorymod
 from .utils import (
     hashutil,
     stringutil,
     urlutil,
 )
 
 
 release = lock.release
 
 # shared features
 sharedbookmarks = b'bookmarks'
 
 
 def _local(path):
     path = util.expandpath(urlutil.urllocalpath(path))
 
     try:
         # we use os.stat() directly here instead of os.path.isfile()
         # because the latter started returning `False` on invalid path
         # exceptions starting in 3.8 and we care about handling
         # invalid paths specially here.
         st = os.stat(path)
         isfile = stat.S_ISREG(st.st_mode)
     # Python 2 raises TypeError, Python 3 ValueError.
     except (TypeError, ValueError) as e:
         raise error.Abort(
             _(b'invalid path %s: %s') % (path, stringutil.forcebytestr(e))
         )
     except OSError:
         isfile = False
 
     return isfile and bundlerepo or localrepo
 
 
 def addbranchrevs(lrepo, other, branches, revs):
     peer = other.peer()  # a courtesy to callers using a localrepo for other
     hashbranch, branches = branches
     if not hashbranch and not branches:
         x = revs or None
         if revs:
             y = revs[0]
         else:
             y = None
         return x, y
     if revs:
         revs = list(revs)
     else:
         revs = []
 
     if not peer.capable(b'branchmap'):
         if branches:
             raise error.Abort(_(b"remote branch lookup not supported"))
         revs.append(hashbranch)
         return revs, revs[0]
 
     with peer.commandexecutor() as e:
         branchmap = e.callcommand(b'branchmap', {}).result()
 
     def primary(branch):
         if branch == b'.':
             if not lrepo:
                 raise error.Abort(_(b"dirstate branch not accessible"))
             branch = lrepo.dirstate.branch()
         if branch in branchmap:
             revs.extend(hex(r) for r in reversed(branchmap[branch]))
             return True
         else:
             return False
 
     for branch in branches:
         if not primary(branch):
             raise error.RepoLookupError(_(b"unknown branch '%s'") % branch)
     if hashbranch:
         if not primary(hashbranch):
             revs.append(hashbranch)
     return revs, revs[0]
 
 
 def parseurl(path, branches=None):
     '''parse url#branch, returning (url, (branch, branches))'''
     msg = b'parseurl(...) moved to mercurial.utils.urlutil'
     util.nouideprecwarn(msg, b'6.0', stacklevel=2)
     return urlutil.parseurl(path, branches=branches)
 
 
 schemes = {
     b'bundle': bundlerepo,
     b'union': unionrepo,
     b'file': _local,
     b'http': httppeer,
     b'https': httppeer,
     b'ssh': sshpeer,
     b'static-http': statichttprepo,
 }
 
 
 def _peerlookup(path):
     u = urlutil.url(path)
     scheme = u.scheme or b'file'
     thing = schemes.get(scheme) or schemes[b'file']
     try:
         return thing(path)
     except TypeError:
         # we can't test callable(thing) because 'thing' can be an unloaded
         # module that implements __call__
         if not util.safehasattr(thing, b'instance'):
             raise
         return thing
 
 
 def islocal(repo):
     '''return true if repo (or path pointing to repo) is local'''
     if isinstance(repo, bytes):
         try:
             return _peerlookup(repo).islocal(repo)
         except AttributeError:
             return False
     return repo.local()
 
 
 def openpath(ui, path, sendaccept=True):
     '''open path with open if local, url.open if remote'''
     pathurl = urlutil.url(path, parsequery=False, parsefragment=False)
     if pathurl.islocal():
         return util.posixfile(pathurl.localpath(), b'rb')
     else:
         return url.open(ui, path, sendaccept=sendaccept)
 
 
 # a list of (ui, repo) functions called for wire peer initialization
 wirepeersetupfuncs = []
 
 
 def _peerorrepo(
     ui, path, create=False, presetupfuncs=None, intents=None, createopts=None
 ):
     """return a repository object for the specified path"""
     obj = _peerlookup(path).instance(
         ui, path, create, intents=intents, createopts=createopts
     )
     ui = getattr(obj, "ui", ui)
     for f in presetupfuncs or []:
         f(ui, obj)
     ui.log(b'extension', b'- executing reposetup hooks\n')
     with util.timedcm('all reposetup') as allreposetupstats:
         for name, module in extensions.extensions(ui):
             ui.log(b'extension', b'  - running reposetup for %s\n', name)
             hook = getattr(module, 'reposetup', None)
             if hook:
                 with util.timedcm('reposetup %r', name) as stats:
                     hook(ui, obj)
                 ui.log(
                     b'extension', b'  > reposetup for %s took %s\n', name, stats
                 )
     ui.log(b'extension', b'> all reposetup took %s\n', allreposetupstats)
     if not obj.local():
         for f in wirepeersetupfuncs:
             f(ui, obj)
     return obj
 
 
 def repository(
     ui,
     path=b'',
     create=False,
     presetupfuncs=None,
     intents=None,
     createopts=None,
 ):
     """return a repository object for the specified path"""
     peer = _peerorrepo(
         ui,
         path,
         create,
         presetupfuncs=presetupfuncs,
         intents=intents,
         createopts=createopts,
     )
     repo = peer.local()
     if not repo:
         raise error.Abort(
             _(b"repository '%s' is not local") % (path or peer.url())
         )
     return repo.filtered(b'visible')
 
 
 def peer(uiorrepo, opts, path, create=False, intents=None, createopts=None):
     '''return a repository peer for the specified path'''
     rui = remoteui(uiorrepo, opts)
     return _peerorrepo(
         rui, path, create, intents=intents, createopts=createopts
     ).peer()
 
 
 def defaultdest(source):
     """return default destination of clone if none is given
 
     >>> defaultdest(b'foo')
     'foo'
     >>> defaultdest(b'/foo/bar')
     'bar'
     >>> defaultdest(b'/')
     ''
     >>> defaultdest(b'')
     ''
     >>> defaultdest(b'http://example.org/')
     ''
     >>> defaultdest(b'http://example.org/foo/')
     'foo'
     """
     path = urlutil.url(source).path
     if not path:
         return b''
     return os.path.basename(os.path.normpath(path))
 
 
 def sharedreposource(repo):
     """Returns repository object for source repository of a shared repo.
 
     If repo is not a shared repository, returns None.
     """
     if repo.sharedpath == repo.path:
         return None
 
     if util.safehasattr(repo, b'srcrepo') and repo.srcrepo:
         return repo.srcrepo
 
     # the sharedpath always ends in the .hg; we want the path to the repo
     source = repo.vfs.split(repo.sharedpath)[0]
     srcurl, branches = urlutil.parseurl(source)
     srcrepo = repository(repo.ui, srcurl)
     repo.srcrepo = srcrepo
     return srcrepo
 
 
 def share(
     ui,
     source,
     dest=None,
     update=True,
     bookmarks=True,
     defaultpath=None,
     relative=False,
 ):
     '''create a shared repository'''
 
     if not islocal(source):
         raise error.Abort(_(b'can only share local repositories'))
 
     if not dest:
         dest = defaultdest(source)
     else:
         dest = urlutil.get_clone_path(ui, dest)[1]
 
     if isinstance(source, bytes):
         origsource, source, branches = urlutil.get_clone_path(ui, source)
         srcrepo = repository(ui, source)
         rev, checkout = addbranchrevs(srcrepo, srcrepo, branches, None)
     else:
         srcrepo = source.local()
         checkout = None
 
     shareditems = set()
     if bookmarks:
         shareditems.add(sharedbookmarks)
 
     r = repository(
         ui,
         dest,
         create=True,
         createopts={
             b'sharedrepo': srcrepo,
             b'sharedrelative': relative,
             b'shareditems': shareditems,
         },
     )
 
     postshare(srcrepo, r, defaultpath=defaultpath)
     r = repository(ui, dest)
     _postshareupdate(r, update, checkout=checkout)
     return r
 
 
 def _prependsourcehgrc(repo):
     """copies the source repo config and prepend it in current repo .hg/hgrc
     on unshare. This is only done if the share was perfomed using share safe
     method where we share config of source in shares"""
     srcvfs = vfsmod.vfs(repo.sharedpath)
     dstvfs = vfsmod.vfs(repo.path)
 
     if not srcvfs.exists(b'hgrc'):
         return
 
     currentconfig = b''
     if dstvfs.exists(b'hgrc'):
         currentconfig = dstvfs.read(b'hgrc')
 
     with dstvfs(b'hgrc', b'wb') as fp:
         sourceconfig = srcvfs.read(b'hgrc')
         fp.write(b"# Config copied from shared source\n")
         fp.write(sourceconfig)
         fp.write(b'\n')
         fp.write(currentconfig)
 
 
 def unshare(ui, repo):
     """convert a shared repository to a normal one
 
     Copy the store data to the repo and remove the sharedpath data.
 
     Returns a new repository object representing the unshared repository.
 
     The passed repository object is not usable after this function is
     called.
     """
 
     with repo.lock():
         # we use locks here because if we race with commit, we
         # can end up with extra data in the cloned revlogs that's
         # not pointed to by changesets, thus causing verify to
         # fail
         destlock = copystore(ui, repo, repo.path)
         with destlock or util.nullcontextmanager():
             if requirements.SHARESAFE_REQUIREMENT in repo.requirements:
                 # we were sharing .hg/hgrc of the share source with the current
                 # repo. We need to copy that while unsharing otherwise it can
                 # disable hooks and other checks
                 _prependsourcehgrc(repo)
 
             sharefile = repo.vfs.join(b'sharedpath')
             util.rename(sharefile, sharefile + b'.old')
 
             repo.requirements.discard(requirements.SHARED_REQUIREMENT)
             repo.requirements.discard(requirements.RELATIVE_SHARED_REQUIREMENT)
             scmutil.writereporequirements(repo)
 
     # Removing share changes some fundamental properties of the repo instance.
     # So we instantiate a new repo object and operate on it rather than
     # try to keep the existing repo usable.
     newrepo = repository(repo.baseui, repo.root, create=False)
 
     # TODO: figure out how to access subrepos that exist, but were previously
     #       removed from .hgsub
     c = newrepo[b'.']
     subs = c.substate
     for s in sorted(subs):
         c.sub(s).unshare()
 
     localrepo.poisonrepository(repo)
 
     return newrepo
 
 
 def postshare(sourcerepo, destrepo, defaultpath=None):
     """Called after a new shared repo is created.
 
     The new repo only has a requirements file and pointer to the source.
     This function configures additional shared data.
 
     Extensions can wrap this function and write additional entries to
     destrepo/.hg/shared to indicate additional pieces of data to be shared.
     """
     default = defaultpath or sourcerepo.ui.config(b'paths', b'default')
     if default:
         template = b'[paths]\ndefault = %s\n'
         destrepo.vfs.write(b'hgrc', util.tonativeeol(template % default))
     if requirements.NARROW_REQUIREMENT in sourcerepo.requirements:
         with destrepo.wlock():
             narrowspec.copytoworkingcopy(destrepo)
 
 
 def _postshareupdate(repo, update, checkout=None):
     """Maybe perform a working directory update after a shared repo is created.
 
     ``update`` can be a boolean or a revision to update to.
     """
     if not update:
         return
 
     repo.ui.status(_(b"updating working directory\n"))
     if update is not True:
         checkout = update
     for test in (checkout, b'default', b'tip'):
         if test is None:
             continue
         try:
             uprev = repo.lookup(test)
             break
         except error.RepoLookupError:
             continue
     _update(repo, uprev)
 
 
 def copystore(ui, srcrepo, destpath):
     """copy files from store of srcrepo in destpath
 
     returns destlock
     """
     destlock = None
     try:
         hardlink = None
         topic = _(b'linking') if hardlink else _(b'copying')
         with ui.makeprogress(topic, unit=_(b'files')) as progress:
             num = 0
             srcpublishing = srcrepo.publishing()
             srcvfs = vfsmod.vfs(srcrepo.sharedpath)
             dstvfs = vfsmod.vfs(destpath)
             for f in srcrepo.store.copylist():
                 if srcpublishing and f.endswith(b'phaseroots'):
                     continue
                 dstbase = os.path.dirname(f)
                 if dstbase and not dstvfs.exists(dstbase):
                     dstvfs.mkdir(dstbase)
                 if srcvfs.exists(f):
                     if f.endswith(b'data'):
                         # 'dstbase' may be empty (e.g. revlog format 0)
                         lockfile = os.path.join(dstbase, b"lock")
                         # lock to avoid premature writing to the target
                         destlock = lock.lock(dstvfs, lockfile)
                     hardlink, n = util.copyfiles(
                         srcvfs.join(f), dstvfs.join(f), hardlink, progress
                     )
                     num += n
             if hardlink:
                 ui.debug(b"linked %d files\n" % num)
             else:
                 ui.debug(b"copied %d files\n" % num)
         return destlock
     except:  # re-raises
         release(destlock)
         raise
 
 
 def clonewithshare(
     ui,
     peeropts,
     sharepath,
     source,
     srcpeer,
     dest,
     pull=False,
     rev=None,
     update=True,
     stream=False,
 ):
     """Perform a clone using a shared repo.
 
     The store for the repository will be located at <sharepath>/.hg. The
     specified revisions will be cloned or pulled from "source". A shared repo
     will be created at "dest" and a working copy will be created if "update" is
     True.
     """
     revs = None
     if rev:
         if not srcpeer.capable(b'lookup'):
             raise error.Abort(
                 _(
                     b"src repository does not support "
                     b"revision lookup and so doesn't "
                     b"support clone by revision"
                 )
             )
 
         # TODO this is batchable.
         remoterevs = []
         for r in rev:
             with srcpeer.commandexecutor() as e:
                 remoterevs.append(
                     e.callcommand(
                         b'lookup',
                         {
                             b'key': r,
                         },
                     ).result()
                 )
         revs = remoterevs
 
     # Obtain a lock before checking for or cloning the pooled repo otherwise
     # 2 clients may race creating or populating it.
     pooldir = os.path.dirname(sharepath)
     # lock class requires the directory to exist.
     try:
         util.makedir(pooldir, False)
     except OSError as e:
         if e.errno != errno.EEXIST:
             raise
 
     poolvfs = vfsmod.vfs(pooldir)
     basename = os.path.basename(sharepath)
 
     with lock.lock(poolvfs, b'%s.lock' % basename):
         if os.path.exists(sharepath):
             ui.status(
                 _(b'(sharing from existing pooled repository %s)\n') % basename
             )
         else:
             ui.status(
                 _(b'(sharing from new pooled repository %s)\n') % basename
             )
             # Always use pull mode because hardlinks in share mode don't work
             # well. Never update because working copies aren't necessary in
             # share mode.
             clone(
                 ui,
                 peeropts,
                 source,
                 dest=sharepath,
                 pull=True,
                 revs=rev,
                 update=False,
                 stream=stream,
             )
 
     # Resolve the value to put in [paths] section for the source.
     if islocal(source):
         defaultpath = os.path.abspath(urlutil.urllocalpath(source))
     else:
         defaultpath = source
 
     sharerepo = repository(ui, path=sharepath)
     destrepo = share(
         ui,
         sharerepo,
         dest=dest,
         update=False,
         bookmarks=False,
         defaultpath=defaultpath,
     )
 
     # We need to perform a pull against the dest repo to fetch bookmarks
     # and other non-store data that isn't shared by default. In the case of
     # non-existing shared repo, this means we pull from the remote twice. This
     # is a bit weird. But at the time it was implemented, there wasn't an easy
     # way to pull just non-changegroup data.
     exchange.pull(destrepo, srcpeer, heads=revs)
 
     _postshareupdate(destrepo, update)
 
     return srcpeer, peer(ui, peeropts, dest)
 
 
 # Recomputing caches is often slow on big repos, so copy them.
 def _copycache(srcrepo, dstcachedir, fname):
     """copy a cache from srcrepo to destcachedir (if it exists)"""
     srcfname = srcrepo.cachevfs.join(fname)
     dstfname = os.path.join(dstcachedir, fname)
     if os.path.exists(srcfname):
         if not os.path.exists(dstcachedir):
             os.mkdir(dstcachedir)
         util.copyfile(srcfname, dstfname)
 
 
 def clone(
     ui,
     peeropts,
     source,
     dest=None,
     pull=False,
     revs=None,
     update=True,
     stream=False,
     branch=None,
     shareopts=None,
     storeincludepats=None,
     storeexcludepats=None,
     depth=None,
 ):
     """Make a copy of an existing repository.
 
     Create a copy of an existing repository in a new directory.  The
     source and destination are URLs, as passed to the repository
     function.  Returns a pair of repository peers, the source and
     newly created destination.
 
     The location of the source is added to the new repository's
     .hg/hgrc file, as the default to be used for future pulls and
     pushes.
 
     If an exception is raised, the partly cloned/updated destination
     repository will be deleted.
 
     Arguments:
 
     source: repository object or URL
 
     dest: URL of destination repository to create (defaults to base
     name of source repository)
 
     pull: always pull from source repository, even in local case or if the
     server prefers streaming
 
     stream: stream raw data uncompressed from repository (fast over
     LAN, slow over WAN)
 
     revs: revision to clone up to (implies pull=True)
 
     update: update working directory after clone completes, if
     destination is local repository (True means update to default rev,
     anything else is treated as a revision)
 
     branch: branches to clone
 
     shareopts: dict of options to control auto sharing behavior. The "pool" key
     activates auto sharing mode and defines the directory for stores. The
     "mode" key determines how to construct the directory name of the shared
     repository. "identity" means the name is derived from the node of the first
     changeset in the repository. "remote" means the name is derived from the
     remote's path/URL. Defaults to "identity."
 
     storeincludepats and storeexcludepats: sets of file patterns to include and
     exclude in the repository copy, respectively. If not defined, all files
     will be included (a "full" clone). Otherwise a "narrow" clone containing
     only the requested files will be performed. If ``storeincludepats`` is not
     defined but ``storeexcludepats`` is, ``storeincludepats`` is assumed to be
     ``path:.``. If both are empty sets, no files will be cloned.
     """
 
     if isinstance(source, bytes):
         src = urlutil.get_clone_path(ui, source, branch)
         origsource, source, branches = src
         srcpeer = peer(ui, peeropts, source)
     else:
         srcpeer = source.peer()  # in case we were called with a localrepo
         branches = (None, branch or [])
         origsource = source = srcpeer.url()
     srclock = destlock = cleandir = None
     destpeer = None
     try:
         revs, checkout = addbranchrevs(srcpeer, srcpeer, branches, revs)
 
         if dest is None:
             dest = defaultdest(source)
             if dest:
                 ui.status(_(b"destination directory: %s\n") % dest)
         else:
             dest = urlutil.get_clone_path(ui, dest)[0]
 
         dest = urlutil.urllocalpath(dest)
         source = urlutil.urllocalpath(source)
 
         if not dest:
             raise error.InputError(_(b"empty destination path is not valid"))
 
         destvfs = vfsmod.vfs(dest, expandpath=True)
         if destvfs.lexists():
             if not destvfs.isdir():
                 raise error.InputError(
                     _(b"destination '%s' already exists") % dest
                 )
             elif destvfs.listdir():
                 raise error.InputError(
                     _(b"destination '%s' is not empty") % dest
                 )
 
         createopts = {}
         narrow = False
 
         if storeincludepats is not None:
             narrowspec.validatepatterns(storeincludepats)
             narrow = True
 
         if storeexcludepats is not None:
             narrowspec.validatepatterns(storeexcludepats)
             narrow = True
 
         if narrow:
             # Include everything by default if only exclusion patterns defined.
             if storeexcludepats and not storeincludepats:
                 storeincludepats = {b'path:.'}
 
             createopts[b'narrowfiles'] = True
 
         if depth:
             createopts[b'shallowfilestore'] = True
 
         if srcpeer.capable(b'lfs-serve'):
             # Repository creation honors the config if it disabled the extension, so
             # we can't just announce that lfs will be enabled.  This check avoids
             # saying that lfs will be enabled, and then saying it's an unknown
             # feature.  The lfs creation option is set in either case so that a
             # requirement is added.  If the extension is explicitly disabled but the
             # requirement is set, the clone aborts early, before transferring any
             # data.
             createopts[b'lfs'] = True
 
             if extensions.disabled_help(b'lfs'):
                 ui.status(
                     _(
                         b'(remote is using large file support (lfs), but it is '
                         b'explicitly disabled in the local configuration)\n'
                     )
                 )
             else:
                 ui.status(
                     _(
                         b'(remote is using large file support (lfs); lfs will '
                         b'be enabled for this repository)\n'
                     )
                 )
 
         shareopts = shareopts or {}
         sharepool = shareopts.get(b'pool')
         sharenamemode = shareopts.get(b'mode')
         if sharepool and islocal(dest):
             sharepath = None
             if sharenamemode == b'identity':
                 # Resolve the name from the initial changeset in the remote
                 # repository. This returns nullid when the remote is empty. It
                 # raises RepoLookupError if revision 0 is filtered or otherwise
                 # not available. If we fail to resolve, sharing is not enabled.
                 try:
                     with srcpeer.commandexecutor() as e:
                         rootnode = e.callcommand(
                             b'lookup',
                             {
                                 b'key': b'0',
                             },
                         ).result()
 
                     if rootnode != sha1nodeconstants.nullid:
                         sharepath = os.path.join(sharepool, hex(rootnode))
                     else:
                         ui.status(
                             _(
                                 b'(not using pooled storage: '
                                 b'remote appears to be empty)\n'
                             )
                         )
                 except error.RepoLookupError:
                     ui.status(
                         _(
                             b'(not using pooled storage: '
                             b'unable to resolve identity of remote)\n'
                         )
                     )
             elif sharenamemode == b'remote':
                 sharepath = os.path.join(
                     sharepool, hex(hashutil.sha1(source).digest())
                 )
             else:
                 raise error.Abort(
                     _(b'unknown share naming mode: %s') % sharenamemode
                 )
 
             # TODO this is a somewhat arbitrary restriction.
             if narrow:
                 ui.status(
                     _(b'(pooled storage not supported for narrow clones)\n')
                 )
                 sharepath = None
 
             if sharepath:
                 return clonewithshare(
                     ui,
                     peeropts,
                     sharepath,
                     source,
                     srcpeer,
                     dest,
                     pull=pull,
                     rev=revs,
                     update=update,
                     stream=stream,
                 )
 
         srcrepo = srcpeer.local()
 
         abspath = origsource
         if islocal(origsource):
             abspath = os.path.abspath(urlutil.urllocalpath(origsource))
 
         if islocal(dest):
             if os.path.exists(dest):
                 # only clean up directories we create ourselves
                 hgdir = os.path.realpath(os.path.join(dest, b".hg"))
                 cleandir = hgdir
             else:
                 cleandir = dest
 
         copy = False
         if (
             srcrepo
             and srcrepo.cancopy()
             and islocal(dest)
             and not phases.hassecret(srcrepo)
         ):
             copy = not pull and not revs
 
         # TODO this is a somewhat arbitrary restriction.
         if narrow:
             copy = False
 
         if copy:
             try:
                 # we use a lock here because if we race with commit, we
                 # can end up with extra data in the cloned revlogs that's
                 # not pointed to by changesets, thus causing verify to
                 # fail
                 srclock = srcrepo.lock(wait=False)
             except error.LockError:
                 copy = False
 
         if copy:
             srcrepo.hook(b'preoutgoing', throw=True, source=b'clone')
 
             destrootpath = urlutil.urllocalpath(dest)
             dest_reqs = localrepo.clone_requirements(ui, createopts, srcrepo)
             localrepo.createrepository(
                 ui,
                 destrootpath,
                 requirements=dest_reqs,
             )
             destrepo = localrepo.makelocalrepository(ui, destrootpath)
+            destlock = destrepo.lock()
+            from . import streamclone  # avoid cycle
 
-            destpath = destrepo.vfs.base
-            destlock = copystore(ui, srcrepo, destpath)
-            # copy bookmarks over
-            srcbookmarks = srcrepo.vfs.join(b'bookmarks')
-            dstbookmarks = os.path.join(destpath, b'bookmarks')
-            if os.path.exists(srcbookmarks):
-                util.copyfile(srcbookmarks, dstbookmarks)
-
-            dstcachedir = os.path.join(destpath, b'cache')
-            for cache in cacheutil.cachetocopy(srcrepo):
-                _copycache(srcrepo, dstcachedir, cache)
+            streamclone.local_copy(srcrepo, destrepo)
 
             # we need to re-init the repo after manually copying the data
             # into it
             destpeer = peer(srcrepo, peeropts, dest)
             srcrepo.hook(
                 b'outgoing', source=b'clone', node=srcrepo.nodeconstants.nullhex
             )
         else:
             try:
                 # only pass ui when no srcrepo
                 destpeer = peer(
                     srcrepo or ui,
                     peeropts,
                     dest,
                     create=True,
                     createopts=createopts,
                 )
             except OSError as inst:
                 if inst.errno == errno.EEXIST:
                     cleandir = None
                     raise error.Abort(
                         _(b"destination '%s' already exists") % dest
                     )
                 raise
 
             if revs:
                 if not srcpeer.capable(b'lookup'):
                     raise error.Abort(
                         _(
                             b"src repository does not support "
                             b"revision lookup and so doesn't "
                             b"support clone by revision"
                         )
                     )
 
                 # TODO this is batchable.
                 remoterevs = []
                 for rev in revs:
                     with srcpeer.commandexecutor() as e:
                         remoterevs.append(
                             e.callcommand(
                                 b'lookup',
                                 {
                                     b'key': rev,
                                 },
                             ).result()
                         )
                 revs = remoterevs
 
                 checkout = revs[0]
             else:
                 revs = None
             local = destpeer.local()
             if local:
                 if narrow:
                     with local.wlock(), local.lock():
                         local.setnarrowpats(storeincludepats, storeexcludepats)
                         narrowspec.copytoworkingcopy(local)
 
                 u = urlutil.url(abspath)
                 defaulturl = bytes(u)
                 local.ui.setconfig(b'paths', b'default', defaulturl, b'clone')
                 if not stream:
                     if pull:
                         stream = False
                     else:
                         stream = None
                 # internal config: ui.quietbookmarkmove
                 overrides = {(b'ui', b'quietbookmarkmove'): True}
                 with local.ui.configoverride(overrides, b'clone'):
                     exchange.pull(
                         local,
                         srcpeer,
                         revs,
                         streamclonerequested=stream,
                         includepats=storeincludepats,
                         excludepats=storeexcludepats,
                         depth=depth,
                     )
             elif srcrepo:
                 # TODO lift restriction once exchange.push() accepts narrow
                 # push.
                 if narrow:
                     raise error.Abort(
                         _(
                             b'narrow clone not available for '
                             b'remote destinations'
                         )
                     )
 
                 exchange.push(
                     srcrepo,
                     destpeer,
                     revs=revs,
                     bookmarks=srcrepo._bookmarks.keys(),
                 )
             else:
                 raise error.Abort(
                     _(b"clone from remote to remote not supported")
                 )
 
         cleandir = None
 
         destrepo = destpeer.local()
         if destrepo:
             template = uimod.samplehgrcs[b'cloned']
             u = urlutil.url(abspath)
             u.passwd = None
             defaulturl = bytes(u)
             destrepo.vfs.write(b'hgrc', util.tonativeeol(template % defaulturl))
             destrepo.ui.setconfig(b'paths', b'default', defaulturl, b'clone')
 
             if ui.configbool(b'experimental', b'remotenames'):
                 logexchange.pullremotenames(destrepo, srcpeer)
 
             if update:
                 if update is not True:
                     with srcpeer.commandexecutor() as e:
                         checkout = e.callcommand(
                             b'lookup',
                             {
                                 b'key': update,
                             },
                         ).result()
 
                 uprev = None
                 status = None
                 if checkout is not None:
                     # Some extensions (at least hg-git and hg-subversion) have
                     # a peer.lookup() implementation that returns a name instead
                     # of a nodeid. We work around it here until we've figured
                     # out a better solution.
                     if len(checkout) == 20 and checkout in destrepo:
                         uprev = checkout
                     elif scmutil.isrevsymbol(destrepo, checkout):
                         uprev = scmutil.revsymbol(destrepo, checkout).node()
                     else:
                         if update is not True:
                             try:
                                 uprev = destrepo.lookup(update)
                             except error.RepoLookupError:
                                 pass
                 if uprev is None:
                     try:
                         if destrepo._activebookmark:
                             uprev = destrepo.lookup(destrepo._activebookmark)
                             update = destrepo._activebookmark
                         else:
                             uprev = destrepo._bookmarks[b'@']
                             update = b'@'
                         bn = destrepo[uprev].branch()
                         if bn == b'default':
                             status = _(b"updating to bookmark %s\n" % update)
                         else:
                             status = (
                                 _(b"updating to bookmark %s on branch %s\n")
                             ) % (update, bn)
                     except KeyError:
                         try:
                             uprev = destrepo.branchtip(b'default')
                         except error.RepoLookupError:
                             uprev = destrepo.lookup(b'tip')
                 if not status:
                     bn = destrepo[uprev].branch()
                     status = _(b"updating to branch %s\n") % bn
                 destrepo.ui.status(status)
                 _update(destrepo, uprev)
                 if update in destrepo._bookmarks:
                     bookmarks.activate(destrepo, update)
             if destlock is not None:
                 release(destlock)
             # here is a tiny windows were someone could end up writing the
             # repository before the cache are sure to be warm. This is "fine"
             # as the only "bad" outcome would be some slowness. That potential
             # slowness already affect reader.
             with destrepo.lock():
                 destrepo.updatecaches(caches=repositorymod.CACHES_POST_CLONE)
     finally:
         release(srclock, destlock)
         if cleandir is not None:
             shutil.rmtree(cleandir, True)
         if srcpeer is not None:
             srcpeer.close()
         if destpeer and destpeer.local() is None:
             destpeer.close()
     return srcpeer, destpeer
 
 
 def _showstats(repo, stats, quietempty=False):
     if quietempty and stats.isempty():
         return
     repo.ui.status(
         _(
             b"%d files updated, %d files merged, "
             b"%d files removed, %d files unresolved\n"
         )
         % (
             stats.updatedcount,
             stats.mergedcount,
             stats.removedcount,
             stats.unresolvedcount,
         )
     )
 
 
 def updaterepo(repo, node, overwrite, updatecheck=None):
     """Update the working directory to node.
 
     When overwrite is set, changes are clobbered, merged else
 
     returns stats (see pydoc mercurial.merge.applyupdates)"""
     repo.ui.deprecwarn(
         b'prefer merge.update() or merge.clean_update() over hg.updaterepo()',
         b'5.7',
     )
     return mergemod._update(
         repo,
         node,
         branchmerge=False,
         force=overwrite,
         labels=[b'working copy', b'destination'],
         updatecheck=updatecheck,
     )
 
 
 def update(repo, node, quietempty=False, updatecheck=None):
     """update the working directory to node"""
     stats = mergemod.update(repo[node], updatecheck=updatecheck)
     _showstats(repo, stats, quietempty)
     if stats.unresolvedcount:
         repo.ui.status(_(b"use 'hg resolve' to retry unresolved file merges\n"))
     return stats.unresolvedcount > 0
 
 
 # naming conflict in clone()
 _update = update
 
 
 def clean(repo, node, show_stats=True, quietempty=False):
     """forcibly switch the working directory to node, clobbering changes"""
     stats = mergemod.clean_update(repo[node])
     assert stats.unresolvedcount == 0
     if show_stats:
         _showstats(repo, stats, quietempty)
     return False
 
 
 # naming conflict in updatetotally()
 _clean = clean
 
 _VALID_UPDATECHECKS = {
     mergemod.UPDATECHECK_ABORT,
     mergemod.UPDATECHECK_NONE,
     mergemod.UPDATECHECK_LINEAR,
     mergemod.UPDATECHECK_NO_CONFLICT,
 }
 
 
 def updatetotally(ui, repo, checkout, brev, clean=False, updatecheck=None):
     """Update the working directory with extra care for non-file components
 
     This takes care of non-file components below:
 
     :bookmark: might be advanced or (in)activated
 
     This takes arguments below:
 
     :checkout: to which revision the working directory is updated
     :brev: a name, which might be a bookmark to be activated after updating
     :clean: whether changes in the working directory can be discarded
     :updatecheck: how to deal with a dirty working directory
 
     Valid values for updatecheck are the UPDATECHECK_* constants
     defined in the merge module. Passing `None` will result in using the
     configured default.
 
      * ABORT: abort if the working directory is dirty
      * NONE: don't check (merge working directory changes into destination)
      * LINEAR: check that update is linear before merging working directory
                changes into destination
      * NO_CONFLICT: check that the update does not result in file merges
 
     This returns whether conflict is detected at updating or not.
     """
     if updatecheck is None:
         updatecheck = ui.config(b'commands', b'update.check')
         if updatecheck not in _VALID_UPDATECHECKS:
             # If not configured, or invalid value configured
             updatecheck = mergemod.UPDATECHECK_LINEAR
     if updatecheck not in _VALID_UPDATECHECKS:
         raise ValueError(
             r'Invalid updatecheck value %r (can accept %r)'
             % (updatecheck, _VALID_UPDATECHECKS)
         )
     with repo.wlock():
         movemarkfrom = None
         warndest = False
         if checkout is None:
             updata = destutil.destupdate(repo, clean=clean)
             checkout, movemarkfrom, brev = updata
             warndest = True
 
         if clean:
             ret = _clean(repo, checkout)
         else:
             if updatecheck == mergemod.UPDATECHECK_ABORT:
                 cmdutil.bailifchanged(repo, merge=False)
                 updatecheck = mergemod.UPDATECHECK_NONE
             ret = _update(repo, checkout, updatecheck=updatecheck)
 
         if not ret and movemarkfrom:
             if movemarkfrom == repo[b'.'].node():
                 pass  # no-op update
             elif bookmarks.update(repo, [movemarkfrom], repo[b'.'].node()):
                 b = ui.label(repo._activebookmark, b'bookmarks.active')
                 ui.status(_(b"updating bookmark %s\n") % b)
             else:
                 # this can happen with a non-linear update
                 b = ui.label(repo._activebookmark, b'bookmarks')
                 ui.status(_(b"(leaving bookmark %s)\n") % b)
                 bookmarks.deactivate(repo)
         elif brev in repo._bookmarks:
             if brev != repo._activebookmark:
                 b = ui.label(brev, b'bookmarks.active')
                 ui.status(_(b"(activating bookmark %s)\n") % b)
             bookmarks.activate(repo, brev)
         elif brev:
             if repo._activebookmark:
                 b = ui.label(repo._activebookmark, b'bookmarks')
                 ui.status(_(b"(leaving bookmark %s)\n") % b)
             bookmarks.deactivate(repo)
 
         if warndest:
             destutil.statusotherdests(ui, repo)
 
     return ret
 
 
 def merge(
     ctx,
     force=False,
     remind=True,
     labels=None,
 ):
     """Branch merge with node, resolving changes. Return true if any
     unresolved conflicts."""
     repo = ctx.repo()
     stats = mergemod.merge(ctx, force=force, labels=labels)
     _showstats(repo, stats)
     if stats.unresolvedcount:
         repo.ui.status(
             _(
                 b"use 'hg resolve' to retry unresolved file merges "
                 b"or 'hg merge --abort' to abandon\n"
             )
         )
     elif remind:
         repo.ui.status(_(b"(branch merge, don't forget to commit)\n"))
     return stats.unresolvedcount > 0
 
 
 def abortmerge(ui, repo):
     ms = mergestatemod.mergestate.read(repo)
     if ms.active():
         # there were conflicts
         node = ms.localctx.hex()
     else:
         # there were no conficts, mergestate was not stored
         node = repo[b'.'].hex()
 
     repo.ui.status(_(b"aborting the merge, updating back to %s\n") % node[:12])
     stats = mergemod.clean_update(repo[node])
     assert stats.unresolvedcount == 0
     _showstats(repo, stats)
 
 
 def _incoming(
     displaychlist,
     subreporecurse,
     ui,
     repo,
     source,
     opts,
     buffered=False,
     subpath=None,
 ):
     """
     Helper for incoming / gincoming.
     displaychlist gets called with
         (remoterepo, incomingchangesetlist, displayer) parameters,
     and is supposed to contain only code that can't be unified.
     """
     srcs = urlutil.get_pull_paths(repo, ui, [source], opts.get(b'branch'))
     srcs = list(srcs)
     if len(srcs) != 1:
         msg = _(b'for now, incoming supports only a single source, %d provided')
         msg %= len(srcs)
         raise error.Abort(msg)
     source, branches = srcs[0]
     if subpath is not None:
         subpath = urlutil.url(subpath)
         if subpath.isabs():
             source = bytes(subpath)
         else:
             p = urlutil.url(source)
             p.path = os.path.normpath(b'%s/%s' % (p.path, subpath))
             source = bytes(p)
     other = peer(repo, opts, source)
     cleanupfn = other.close
     try:
         ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(source))
         revs, checkout = addbranchrevs(repo, other, branches, opts.get(b'rev'))
 
         if revs:
             revs = [other.lookup(rev) for rev in revs]
         other, chlist, cleanupfn = bundlerepo.getremotechanges(
             ui, repo, other, revs, opts[b"bundle"], opts[b"force"]
         )
 
         if not chlist:
             ui.status(_(b"no changes found\n"))
             return subreporecurse()
         ui.pager(b'incoming')
         displayer = logcmdutil.changesetdisplayer(
             ui, other, opts, buffered=buffered
         )
         displaychlist(other, chlist, displayer)
         displayer.close()
     finally:
         cleanupfn()
     subreporecurse()
     return 0  # exit code is zero since we found incoming changes
 
 
 def incoming(ui, repo, source, opts, subpath=None):
     def subreporecurse():
         ret = 1
         if opts.get(b'subrepos'):
             ctx = repo[None]
             for subpath in sorted(ctx.substate):
                 sub = ctx.sub(subpath)
                 ret = min(ret, sub.incoming(ui, source, opts))
         return ret
 
     def display(other, chlist, displayer):
         limit = logcmdutil.getlimit(opts)
         if opts.get(b'newest_first'):
             chlist.reverse()
         count = 0
         for n in chlist:
             if limit is not None and count >= limit:
                 break
             parents = [
                 p for p in other.changelog.parents(n) if p != repo.nullid
             ]
             if opts.get(b'no_merges') and len(parents) == 2:
                 continue
             count += 1
             displayer.show(other[n])
 
     return _incoming(
         display, subreporecurse, ui, repo, source, opts, subpath=subpath
     )
 
 
 def _outgoing(ui, repo, dests, opts, subpath=None):
     out = set()
     others = []
     for path in urlutil.get_push_paths(repo, ui, dests):
         dest = path.pushloc or path.loc
         if subpath is not None:
             subpath = urlutil.url(subpath)
             if subpath.isabs():
                 dest = bytes(subpath)
             else:
                 p = urlutil.url(dest)
                 p.path = os.path.normpath(b'%s/%s' % (p.path, subpath))
                 dest = bytes(p)
         branches = path.branch, opts.get(b'branch') or []
 
         ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(dest))
         revs, checkout = addbranchrevs(repo, repo, branches, opts.get(b'rev'))
         if revs:
             revs = [repo[rev].node() for rev in scmutil.revrange(repo, revs)]
 
         other = peer(repo, opts, dest)
         try:
             outgoing = discovery.findcommonoutgoing(
                 repo, other, revs, force=opts.get(b'force')
             )
             o = outgoing.missing
             out.update(o)
             if not o:
                 scmutil.nochangesfound(repo.ui, repo, outgoing.excluded)
             others.append(other)
         except:  # re-raises
             other.close()
             raise
     # make sure this is ordered by revision number
     outgoing_revs = list(out)
     cl = repo.changelog
     outgoing_revs.sort(key=cl.rev)
     return outgoing_revs, others
 
 
 def _outgoing_recurse(ui, repo, dests, opts):
     ret = 1
     if opts.get(b'subrepos'):
         ctx = repo[None]
         for subpath in sorted(ctx.substate):
             sub = ctx.sub(subpath)
             ret = min(ret, sub.outgoing(ui, dests, opts))
     return ret
 
 
 def _outgoing_filter(repo, revs, opts):
     """apply revision filtering/ordering option for outgoing"""
     limit = logcmdutil.getlimit(opts)
     no_merges = opts.get(b'no_merges')
     if opts.get(b'newest_first'):
         revs.reverse()
     if limit is None and not no_merges:
         for r in revs:
             yield r
         return
 
     count = 0
     cl = repo.changelog
     for n in revs:
         if limit is not None and count >= limit:
             break
         parents = [p for p in cl.parents(n) if p != repo.nullid]
         if no_merges and len(parents) == 2:
             continue
         count += 1
         yield n
 
 
 def outgoing(ui, repo, dests, opts, subpath=None):
     if opts.get(b'graph'):
         logcmdutil.checkunsupportedgraphflags([], opts)
     o, others = _outgoing(ui, repo, dests, opts, subpath=subpath)
     ret = 1
     try:
         if o:
             ret = 0
 
             if opts.get(b'graph'):
                 revdag = logcmdutil.graphrevs(repo, o, opts)
                 ui.pager(b'outgoing')
                 displayer = logcmdutil.changesetdisplayer(
                     ui, repo, opts, buffered=True
                 )
                 logcmdutil.displaygraph(
                     ui, repo, revdag, displayer, graphmod.asciiedges
                 )
             else:
                 ui.pager(b'outgoing')
                 displayer = logcmdutil.changesetdisplayer(ui, repo, opts)
                 for n in _outgoing_filter(repo, o, opts):
                     displayer.show(repo[n])
                 displayer.close()
         for oth in others:
             cmdutil.outgoinghooks(ui, repo, oth, opts, o)
             ret = min(ret, _outgoing_recurse(ui, repo, dests, opts))
         return ret  # exit code is zero since we found outgoing changes
     finally:
         for oth in others:
             oth.close()
 
 
 def verify(repo, level=None):
     """verify the consistency of a repository"""
     ret = verifymod.verify(repo, level=level)
 
     # Broken subrepo references in hidden csets don't seem worth worrying about,
     # since they can't be pushed/pulled, and --hidden can be used if they are a
     # concern.
 
     # pathto() is needed for -R case
     revs = repo.revs(
         b"filelog(%s)", util.pathto(repo.root, repo.getcwd(), b'.hgsubstate')
     )
 
     if revs:
         repo.ui.status(_(b'checking subrepo links\n'))
         for rev in revs:
             ctx = repo[rev]
             try:
                 for subpath in ctx.substate:
                     try:
                         ret = (
                             ctx.sub(subpath, allowcreate=False).verify() or ret
                         )
                     except error.RepoError as e:
                         repo.ui.warn(b'%d: %s\n' % (rev, e))
             except Exception:
                 repo.ui.warn(
                     _(b'.hgsubstate is corrupt in revision %s\n')
                     % short(ctx.node())
                 )
 
     return ret
 
 
 def remoteui(src, opts):
     """build a remote ui from ui or repo and opts"""
     if util.safehasattr(src, b'baseui'):  # looks like a repository
         dst = src.baseui.copy()  # drop repo-specific config
         src = src.ui  # copy target options from repo
     else:  # assume it's a global ui object
         dst = src.copy()  # keep all global options
 
     # copy ssh-specific options
     for o in b'ssh', b'remotecmd':
         v = opts.get(o) or src.config(b'ui', o)
         if v:
             dst.setconfig(b"ui", o, v, b'copied')
 
     # copy bundle-specific options
     r = src.config(b'bundle', b'mainreporoot')
     if r:
         dst.setconfig(b'bundle', b'mainreporoot', r, b'copied')
 
     # copy selected local settings to the remote ui
     for sect in (b'auth', b'hostfingerprints', b'hostsecurity', b'http_proxy'):
         for key, val in src.configitems(sect):
             dst.setconfig(sect, key, val, b'copied')
     v = src.config(b'web', b'cacerts')
     if v:
         dst.setconfig(b'web', b'cacerts', util.expandpath(v), b'copied')
 
     return dst
 
 
 # Files of interest
 # Used to check if the repository has changed looking at mtime and size of
 # these files.
 foi = [
     (b'spath', b'00changelog.i'),
     (b'spath', b'phaseroots'),  # ! phase can change content at the same size
     (b'spath', b'obsstore'),
     (b'path', b'bookmarks'),  # ! bookmark can change content at the same size
 ]
 
 
 class cachedlocalrepo(object):
     """Holds a localrepository that can be cached and reused."""
 
     def __init__(self, repo):
         """Create a new cached repo from an existing repo.
 
         We assume the passed in repo was recently created. If the
         repo has changed between when it was created and when it was
         turned into a cache, it may not refresh properly.
         """
         assert isinstance(repo, localrepo.localrepository)
         self._repo = repo
         self._state, self.mtime = self._repostate()
         self._filtername = repo.filtername
 
     def fetch(self):
         """Refresh (if necessary) and return a repository.
 
         If the cached instance is out of date, it will be recreated
         automatically and returned.
 
         Returns a tuple of the repo and a boolean indicating whether a new
         repo instance was created.
         """
         # We compare the mtimes and sizes of some well-known files to
         # determine if the repo changed. This is not precise, as mtimes
         # are susceptible to clock skew and imprecise filesystems and
         # file content can change while maintaining the same size.
 
         state, mtime = self._repostate()
         if state == self._state:
             return self._repo, False
 
         repo = repository(self._repo.baseui, self._repo.url())
         if self._filtername:
             self._repo = repo.filtered(self._filtername)
         else:
             self._repo = repo.unfiltered()
         self._state = state
         self.mtime = mtime
 
         return self._repo, True
 
     def _repostate(self):
         state = []
         maxmtime = -1
         for attr, fname in foi:
             prefix = getattr(self._repo, attr)
             p = os.path.join(prefix, fname)
             try:
                 st = os.stat(p)
             except OSError:
                 st = os.stat(prefix)
             state.append((st[stat.ST_MTIME], st.st_size))
             maxmtime = max(maxmtime, st[stat.ST_MTIME])
 
         return tuple(state), maxmtime
 
     def copy(self):
         """Obtain a copy of this class instance.
 
         A new localrepository instance is obtained. The new instance should be
         completely independent of the original.
         """
         repo = repository(self._repo.baseui, self._repo.origroot)
         if self._filtername:
             repo = repo.filtered(self._filtername)
         else:
             repo = repo.unfiltered()
         c = cachedlocalrepo(repo)
         c._state = self._state
         c.mtime = self.mtime
         return c

mercurial/streamclone.py

@@ -1,773 +1,879 b''
 # streamclone.py - producing and consuming streaming repository data
 #
 # Copyright 2015 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import contextlib
+import errno
 import os
 import struct
 
 from .i18n import _
 from .pycompat import open
 from .interfaces import repository
 from . import (
+    bookmarks,
     cacheutil,
     error,
     narrowspec,
     phases,
     pycompat,
     requirements as requirementsmod,
     scmutil,
     store,
     util,
 )
+from .utils import (
+    stringutil,
+)
 
 
 def canperformstreamclone(pullop, bundle2=False):
     """Whether it is possible to perform a streaming clone as part of pull.
 
     ``bundle2`` will cause the function to consider stream clone through
     bundle2 and only through bundle2.
 
     Returns a tuple of (supported, requirements). ``supported`` is True if
     streaming clone is supported and False otherwise. ``requirements`` is
     a set of repo requirements from the remote, or ``None`` if stream clone
     isn't supported.
     """
     repo = pullop.repo
     remote = pullop.remote
 
     bundle2supported = False
     if pullop.canusebundle2:
         if b'v2' in pullop.remotebundle2caps.get(b'stream', []):
             bundle2supported = True
         # else
         # Server doesn't support bundle2 stream clone or doesn't support
         # the versions we support. Fall back and possibly allow legacy.
 
     # Ensures legacy code path uses available bundle2.
     if bundle2supported and not bundle2:
         return False, None
     # Ensures bundle2 doesn't try to do a stream clone if it isn't supported.
     elif bundle2 and not bundle2supported:
         return False, None
 
     # Streaming clone only works on empty repositories.
     if len(repo):
         return False, None
 
     # Streaming clone only works if all data is being requested.
     if pullop.heads:
         return False, None
 
     streamrequested = pullop.streamclonerequested
 
     # If we don't have a preference, let the server decide for us. This
     # likely only comes into play in LANs.
     if streamrequested is None:
         # The server can advertise whether to prefer streaming clone.
         streamrequested = remote.capable(b'stream-preferred')
 
     if not streamrequested:
         return False, None
 
     # In order for stream clone to work, the client has to support all the
     # requirements advertised by the server.
     #
     # The server advertises its requirements via the "stream" and "streamreqs"
     # capability. "stream" (a value-less capability) is advertised if and only
     # if the only requirement is "revlogv1." Else, the "streamreqs" capability
     # is advertised and contains a comma-delimited list of requirements.
     requirements = set()
     if remote.capable(b'stream'):
         requirements.add(requirementsmod.REVLOGV1_REQUIREMENT)
     else:
         streamreqs = remote.capable(b'streamreqs')
         # This is weird and shouldn't happen with modern servers.
         if not streamreqs:
             pullop.repo.ui.warn(
                 _(
                     b'warning: stream clone requested but server has them '
                     b'disabled\n'
                 )
             )
             return False, None
 
         streamreqs = set(streamreqs.split(b','))
         # Server requires something we don't support. Bail.
         missingreqs = streamreqs - repo.supportedformats
         if missingreqs:
             pullop.repo.ui.warn(
                 _(
                     b'warning: stream clone requested but client is missing '
                     b'requirements: %s\n'
                 )
                 % b', '.join(sorted(missingreqs))
             )
             pullop.repo.ui.warn(
                 _(
                     b'(see https://www.mercurial-scm.org/wiki/MissingRequirement '
                     b'for more information)\n'
                 )
             )
             return False, None
         requirements = streamreqs
 
     return True, requirements
 
 
 def maybeperformlegacystreamclone(pullop):
     """Possibly perform a legacy stream clone operation.
 
     Legacy stream clones are performed as part of pull but before all other
     operations.
 
     A legacy stream clone will not be performed if a bundle2 stream clone is
     supported.
     """
     from . import localrepo
 
     supported, requirements = canperformstreamclone(pullop)
 
     if not supported:
         return
 
     repo = pullop.repo
     remote = pullop.remote
 
     # Save remote branchmap. We will use it later to speed up branchcache
     # creation.
     rbranchmap = None
     if remote.capable(b'branchmap'):
         with remote.commandexecutor() as e:
             rbranchmap = e.callcommand(b'branchmap', {}).result()
 
     repo.ui.status(_(b'streaming all changes\n'))
 
     with remote.commandexecutor() as e:
         fp = e.callcommand(b'stream_out', {}).result()
 
     # TODO strictly speaking, this code should all be inside the context
     # manager because the context manager is supposed to ensure all wire state
     # is flushed when exiting. But the legacy peers don't do this, so it
     # doesn't matter.
     l = fp.readline()
     try:
         resp = int(l)
     except ValueError:
         raise error.ResponseError(
             _(b'unexpected response from remote server:'), l
         )
     if resp == 1:
         raise error.Abort(_(b'operation forbidden by server'))
     elif resp == 2:
         raise error.Abort(_(b'locking the remote repository failed'))
     elif resp != 0:
         raise error.Abort(_(b'the server sent an unknown error code'))
 
     l = fp.readline()
     try:
         filecount, bytecount = map(int, l.split(b' ', 1))
     except (ValueError, TypeError):
         raise error.ResponseError(
             _(b'unexpected response from remote server:'), l
         )
 
     with repo.lock():
         consumev1(repo, fp, filecount, bytecount)
 
         # new requirements = old non-format requirements +
         #                    new format-related remote requirements
         # requirements from the streamed-in repository
         repo.requirements = requirements | (
             repo.requirements - repo.supportedformats
         )
         repo.svfs.options = localrepo.resolvestorevfsoptions(
             repo.ui, repo.requirements, repo.features
         )
         scmutil.writereporequirements(repo)
 
         if rbranchmap:
             repo._branchcaches.replace(repo, rbranchmap)
 
         repo.invalidate()
 
 
 def allowservergeneration(repo):
     """Whether streaming clones are allowed from the server."""
     if repository.REPO_FEATURE_STREAM_CLONE not in repo.features:
         return False
 
     if not repo.ui.configbool(b'server', b'uncompressed', untrusted=True):
         return False
 
     # The way stream clone works makes it impossible to hide secret changesets.
     # So don't allow this by default.
     secret = phases.hassecret(repo)
     if secret:
         return repo.ui.configbool(b'server', b'uncompressedallowsecret')
 
     return True
 
 
 # This is it's own function so extensions can override it.
 def _walkstreamfiles(repo, matcher=None):
     return repo.store.walk(matcher)
 
 
 def generatev1(repo):
     """Emit content for version 1 of a streaming clone.
 
     This returns a 3-tuple of (file count, byte size, data iterator).
 
     The data iterator consists of N entries for each file being transferred.
     Each file entry starts as a line with the file name and integer size
     delimited by a null byte.
 
     The raw file data follows. Following the raw file data is the next file
     entry, or EOF.
 
     When used on the wire protocol, an additional line indicating protocol
     success will be prepended to the stream. This function is not responsible
     for adding it.
 
     This function will obtain a repository lock to ensure a consistent view of
     the store is captured. It therefore may raise LockError.
     """
     entries = []
     total_bytes = 0
     # Get consistent snapshot of repo, lock during scan.
     with repo.lock():
         repo.ui.debug(b'scanning\n')
         for file_type, name, ename, size in _walkstreamfiles(repo):
             if size:
                 entries.append((name, size))
                 total_bytes += size
         _test_sync_point_walk_1(repo)
     _test_sync_point_walk_2(repo)
 
     repo.ui.debug(
         b'%d files, %d bytes to transfer\n' % (len(entries), total_bytes)
     )
 
     svfs = repo.svfs
     debugflag = repo.ui.debugflag
 
     def emitrevlogdata():
         for name, size in entries:
             if debugflag:
                 repo.ui.debug(b'sending %s (%d bytes)\n' % (name, size))
             # partially encode name over the wire for backwards compat
             yield b'%s\0%d\n' % (store.encodedir(name), size)
             # auditing at this stage is both pointless (paths are already
             # trusted by the local repo) and expensive
             with svfs(name, b'rb', auditpath=False) as fp:
                 if size <= 65536:
                     yield fp.read(size)
                 else:
                     for chunk in util.filechunkiter(fp, limit=size):
                         yield chunk
 
     return len(entries), total_bytes, emitrevlogdata()
 
 
 def generatev1wireproto(repo):
     """Emit content for version 1 of streaming clone suitable for the wire.
 
     This is the data output from ``generatev1()`` with 2 header lines. The
     first line indicates overall success. The 2nd contains the file count and
     byte size of payload.
 
     The success line contains "0" for success, "1" for stream generation not
     allowed, and "2" for error locking the repository (possibly indicating
     a permissions error for the server process).
     """
     if not allowservergeneration(repo):
         yield b'1\n'
         return
 
     try:
         filecount, bytecount, it = generatev1(repo)
     except error.LockError:
         yield b'2\n'
         return
 
     # Indicates successful response.
     yield b'0\n'
     yield b'%d %d\n' % (filecount, bytecount)
     for chunk in it:
         yield chunk
 
 
 def generatebundlev1(repo, compression=b'UN'):
     """Emit content for version 1 of a stream clone bundle.
 
     The first 4 bytes of the output ("HGS1") denote this as stream clone
     bundle version 1.
 
     The next 2 bytes indicate the compression type. Only "UN" is currently
     supported.
 
     The next 16 bytes are two 64-bit big endian unsigned integers indicating
     file count and byte count, respectively.
 
     The next 2 bytes is a 16-bit big endian unsigned short declaring the length
     of the requirements string, including a trailing \0. The following N bytes
     are the requirements string, which is ASCII containing a comma-delimited
     list of repo requirements that are needed to support the data.
 
     The remaining content is the output of ``generatev1()`` (which may be
     compressed in the future).
 
     Returns a tuple of (requirements, data generator).
     """
     if compression != b'UN':
         raise ValueError(b'we do not support the compression argument yet')
 
     requirements = repo.requirements & repo.supportedformats
     requires = b','.join(sorted(requirements))
 
     def gen():
         yield b'HGS1'
         yield compression
 
         filecount, bytecount, it = generatev1(repo)
         repo.ui.status(
             _(b'writing %d bytes for %d files\n') % (bytecount, filecount)
         )
 
         yield struct.pack(b'>QQ', filecount, bytecount)
         yield struct.pack(b'>H', len(requires) + 1)
         yield requires + b'\0'
 
         # This is where we'll add compression in the future.
         assert compression == b'UN'
 
         progress = repo.ui.makeprogress(
             _(b'bundle'), total=bytecount, unit=_(b'bytes')
         )
         progress.update(0)
 
         for chunk in it:
             progress.increment(step=len(chunk))
             yield chunk
 
         progress.complete()
 
     return requirements, gen()
 
 
 def consumev1(repo, fp, filecount, bytecount):
     """Apply the contents from version 1 of a streaming clone file handle.
 
     This takes the output from "stream_out" and applies it to the specified
     repository.
 
     Like "stream_out," the status line added by the wire protocol is not
     handled by this function.
     """
     with repo.lock():
         repo.ui.status(
             _(b'%d files to transfer, %s of data\n')
             % (filecount, util.bytecount(bytecount))
         )
         progress = repo.ui.makeprogress(
             _(b'clone'), total=bytecount, unit=_(b'bytes')
         )
         progress.update(0)
         start = util.timer()
 
         # TODO: get rid of (potential) inconsistency
         #
         # If transaction is started and any @filecache property is
         # changed at this point, it causes inconsistency between
         # in-memory cached property and streamclone-ed file on the
         # disk. Nested transaction prevents transaction scope "clone"
         # below from writing in-memory changes out at the end of it,
         # even though in-memory changes are discarded at the end of it
         # regardless of transaction nesting.
         #
         # But transaction nesting can't be simply prohibited, because
         # nesting occurs also in ordinary case (e.g. enabling
         # clonebundles).
 
         with repo.transaction(b'clone'):
             with repo.svfs.backgroundclosing(repo.ui, expectedcount=filecount):
                 for i in pycompat.xrange(filecount):
                     # XXX doesn't support '\n' or '\r' in filenames
                     l = fp.readline()
                     try:
                         name, size = l.split(b'\0', 1)
                         size = int(size)
                     except (ValueError, TypeError):
                         raise error.ResponseError(
                             _(b'unexpected response from remote server:'), l
                         )
                     if repo.ui.debugflag:
                         repo.ui.debug(
                             b'adding %s (%s)\n' % (name, util.bytecount(size))
                         )
                     # for backwards compat, name was partially encoded
                     path = store.decodedir(name)
                     with repo.svfs(path, b'w', backgroundclose=True) as ofp:
                         for chunk in util.filechunkiter(fp, limit=size):
                             progress.increment(step=len(chunk))
                             ofp.write(chunk)
 
             # force @filecache properties to be reloaded from
             # streamclone-ed file at next access
             repo.invalidate(clearfilecache=True)
 
         elapsed = util.timer() - start
         if elapsed <= 0:
             elapsed = 0.001
         progress.complete()
         repo.ui.status(
             _(b'transferred %s in %.1f seconds (%s/sec)\n')
             % (
                 util.bytecount(bytecount),
                 elapsed,
                 util.bytecount(bytecount / elapsed),
             )
         )
 
 
 def readbundle1header(fp):
     compression = fp.read(2)
     if compression != b'UN':
         raise error.Abort(
             _(
                 b'only uncompressed stream clone bundles are '
                 b'supported; got %s'
             )
             % compression
         )
 
     filecount, bytecount = struct.unpack(b'>QQ', fp.read(16))
     requireslen = struct.unpack(b'>H', fp.read(2))[0]
     requires = fp.read(requireslen)
 
     if not requires.endswith(b'\0'):
         raise error.Abort(
             _(
                 b'malformed stream clone bundle: '
                 b'requirements not properly encoded'
             )
         )
 
     requirements = set(requires.rstrip(b'\0').split(b','))
 
     return filecount, bytecount, requirements
 
 
 def applybundlev1(repo, fp):
     """Apply the content from a stream clone bundle version 1.
 
     We assume the 4 byte header has been read and validated and the file handle
     is at the 2 byte compression identifier.
     """
     if len(repo):
         raise error.Abort(
             _(b'cannot apply stream clone bundle on non-empty repo')
         )
 
     filecount, bytecount, requirements = readbundle1header(fp)
     missingreqs = requirements - repo.supportedformats
     if missingreqs:
         raise error.Abort(
             _(b'unable to apply stream clone: unsupported format: %s')
             % b', '.join(sorted(missingreqs))
         )
 
     consumev1(repo, fp, filecount, bytecount)
 
 
 class streamcloneapplier(object):
     """Class to manage applying streaming clone bundles.
 
     We need to wrap ``applybundlev1()`` in a dedicated type to enable bundle
     readers to perform bundle type-specific functionality.
     """
 
     def __init__(self, fh):
         self._fh = fh
 
     def apply(self, repo):
         return applybundlev1(repo, self._fh)
 
 
 # type of file to stream
 _fileappend = 0  # append only file
 _filefull = 1  # full snapshot file
 
 # Source of the file
 _srcstore = b's'  # store (svfs)
 _srccache = b'c'  # cache (cache)
 
 # This is it's own function so extensions can override it.
 def _walkstreamfullstorefiles(repo):
     """list snapshot file from the store"""
     fnames = []
     if not repo.publishing():
         fnames.append(b'phaseroots')
     return fnames
 
 
 def _filterfull(entry, copy, vfsmap):
     """actually copy the snapshot files"""
     src, name, ftype, data = entry
     if ftype != _filefull:
         return entry
     return (src, name, ftype, copy(vfsmap[src].join(name)))
 
 
 @contextlib.contextmanager
 def maketempcopies():
     """return a function to temporary copy file"""
     files = []
     try:
 
         def copy(src):
             fd, dst = pycompat.mkstemp()
             os.close(fd)
             files.append(dst)
             util.copyfiles(src, dst, hardlink=True)
             return dst
 
         yield copy
     finally:
         for tmp in files:
             util.tryunlink(tmp)
 
 
 def _makemap(repo):
     """make a (src -> vfs) map for the repo"""
     vfsmap = {
         _srcstore: repo.svfs,
         _srccache: repo.cachevfs,
     }
     # we keep repo.vfs out of the on purpose, ther are too many danger there
     # (eg: .hg/hgrc)
     assert repo.vfs not in vfsmap.values()
 
     return vfsmap
 
 
 def _emit2(repo, entries, totalfilesize):
     """actually emit the stream bundle"""
     vfsmap = _makemap(repo)
     progress = repo.ui.makeprogress(
         _(b'bundle'), total=totalfilesize, unit=_(b'bytes')
     )
     progress.update(0)
     with maketempcopies() as copy, progress:
         # copy is delayed until we are in the try
         entries = [_filterfull(e, copy, vfsmap) for e in entries]
         yield None  # this release the lock on the repository
         seen = 0
 
         for src, name, ftype, data in entries:
             vfs = vfsmap[src]
             yield src
             yield util.uvarintencode(len(name))
             if ftype == _fileappend:
                 fp = vfs(name)
                 size = data
             elif ftype == _filefull:
                 fp = open(data, b'rb')
                 size = util.fstat(fp).st_size
             try:
                 yield util.uvarintencode(size)
                 yield name
                 if size <= 65536:
                     chunks = (fp.read(size),)
                 else:
                     chunks = util.filechunkiter(fp, limit=size)
                 for chunk in chunks:
                     seen += len(chunk)
                     progress.update(seen)
                     yield chunk
             finally:
                 fp.close()
 
 
 def _test_sync_point_walk_1(repo):
     """a function for synchronisation during tests"""
 
 
 def _test_sync_point_walk_2(repo):
     """a function for synchronisation during tests"""
 
 
 def _v2_walk(repo, includes, excludes, includeobsmarkers):
     """emit a seris of files information useful to clone a repo
 
     return (entries, totalfilesize)
 
     entries is a list of tuple (vfs-key, file-path, file-type, size)
 
     - `vfs-key`: is a key to the right vfs to write the file (see _makemap)
     - `name`: file path of the file to copy (to be feed to the vfss)
     - `file-type`: do this file need to be copied with the source lock ?
     - `size`: the size of the file (or None)
     """
     assert repo._currentlock(repo._lockref) is not None
     entries = []
     totalfilesize = 0
 
     matcher = None
     if includes or excludes:
         matcher = narrowspec.match(repo.root, includes, excludes)
 
     for rl_type, name, ename, size in _walkstreamfiles(repo, matcher):
         if size:
             ft = _fileappend
             if rl_type & store.FILEFLAGS_VOLATILE:
                 ft = _filefull
             entries.append((_srcstore, name, ft, size))
             totalfilesize += size
     for name in _walkstreamfullstorefiles(repo):
         if repo.svfs.exists(name):
             totalfilesize += repo.svfs.lstat(name).st_size
             entries.append((_srcstore, name, _filefull, None))
     if includeobsmarkers and repo.svfs.exists(b'obsstore'):
         totalfilesize += repo.svfs.lstat(b'obsstore').st_size
         entries.append((_srcstore, b'obsstore', _filefull, None))
     for name in cacheutil.cachetocopy(repo):
         if repo.cachevfs.exists(name):
             totalfilesize += repo.cachevfs.lstat(name).st_size
             entries.append((_srccache, name, _filefull, None))
     return entries, totalfilesize
 
 
 def generatev2(repo, includes, excludes, includeobsmarkers):
     """Emit content for version 2 of a streaming clone.
 
     the data stream consists the following entries:
     1) A char representing the file destination (eg: store or cache)
     2) A varint containing the length of the filename
     3) A varint containing the length of file data
     4) N bytes containing the filename (the internal, store-agnostic form)
     5) N bytes containing the file data
 
     Returns a 3-tuple of (file count, file size, data iterator).
     """
 
     with repo.lock():
 
         repo.ui.debug(b'scanning\n')
 
         entries, totalfilesize = _v2_walk(
             repo,
             includes=includes,
             excludes=excludes,
             includeobsmarkers=includeobsmarkers,
         )
 
         chunks = _emit2(repo, entries, totalfilesize)
         first = next(chunks)
         assert first is None
         _test_sync_point_walk_1(repo)
     _test_sync_point_walk_2(repo)
 
     return len(entries), totalfilesize, chunks
 
 
 @contextlib.contextmanager
 def nested(*ctxs):
     this = ctxs[0]
     rest = ctxs[1:]
     with this:
         if rest:
             with nested(*rest):
                 yield
         else:
             yield
 
 
 def consumev2(repo, fp, filecount, filesize):
     """Apply the contents from a version 2 streaming clone.
 
     Data is read from an object that only needs to provide a ``read(size)``
     method.
     """
     with repo.lock():
         repo.ui.status(
             _(b'%d files to transfer, %s of data\n')
             % (filecount, util.bytecount(filesize))
         )
 
         start = util.timer()
         progress = repo.ui.makeprogress(
             _(b'clone'), total=filesize, unit=_(b'bytes')
         )
         progress.update(0)
 
         vfsmap = _makemap(repo)
 
         with repo.transaction(b'clone'):
             ctxs = (vfs.backgroundclosing(repo.ui) for vfs in vfsmap.values())
             with nested(*ctxs):
                 for i in range(filecount):
                     src = util.readexactly(fp, 1)
                     vfs = vfsmap[src]
                     namelen = util.uvarintdecodestream(fp)
                     datalen = util.uvarintdecodestream(fp)
 
                     name = util.readexactly(fp, namelen)
 
                     if repo.ui.debugflag:
                         repo.ui.debug(
                             b'adding [%s] %s (%s)\n'
                             % (src, name, util.bytecount(datalen))
                         )
 
                     with vfs(name, b'w') as ofp:
                         for chunk in util.filechunkiter(fp, limit=datalen):
                             progress.increment(step=len(chunk))
                             ofp.write(chunk)
 
             # force @filecache properties to be reloaded from
             # streamclone-ed file at next access
             repo.invalidate(clearfilecache=True)
 
         elapsed = util.timer() - start
         if elapsed <= 0:
             elapsed = 0.001
         repo.ui.status(
             _(b'transferred %s in %.1f seconds (%s/sec)\n')
             % (
                 util.bytecount(progress.pos),
                 elapsed,
                 util.bytecount(progress.pos / elapsed),
             )
         )
         progress.complete()
 
 
 def applybundlev2(repo, fp, filecount, filesize, requirements):
     from . import localrepo
 
     missingreqs = [r for r in requirements if r not in repo.supported]
     if missingreqs:
         raise error.Abort(
             _(b'unable to apply stream clone: unsupported format: %s')
             % b', '.join(sorted(missingreqs))
         )
 
     consumev2(repo, fp, filecount, filesize)
 
     # new requirements = old non-format requirements +
     #                    new format-related remote requirements
     # requirements from the streamed-in repository
     repo.requirements = set(requirements) | (
         repo.requirements - repo.supportedformats
     )
     repo.svfs.options = localrepo.resolvestorevfsoptions(
         repo.ui, repo.requirements, repo.features
     )
     scmutil.writereporequirements(repo)
+
+
+def _copy_files(src_vfs_map, dst_vfs_map, entries, progress):
+    hardlink = [True]
+
+    def copy_used():
+        hardlink[0] = False
+        progress.topic = _(b'copying')
+
+    for k, path, size in entries:
+        src_vfs = src_vfs_map[k]
+        dst_vfs = dst_vfs_map[k]
+        src_path = src_vfs.join(path)
+        dst_path = dst_vfs.join(path)
+        dirname = dst_vfs.dirname(path)
+        if not dst_vfs.exists(dirname):
+            dst_vfs.makedirs(dirname)
+        dst_vfs.register_file(path)
+        # XXX we could use the #nb_bytes argument.
+        util.copyfile(
+            src_path,
+            dst_path,
+            hardlink=hardlink[0],
+            no_hardlink_cb=copy_used,
+            check_fs_hardlink=False,
+        )
+        progress.increment()
+    return hardlink[0]
+
+
+def local_copy(src_repo, dest_repo):
+    """copy all content from one local repository to another
+
+    This is useful for local clone"""
+    src_store_requirements = {
+        r
+        for r in src_repo.requirements
+        if r not in requirementsmod.WORKING_DIR_REQUIREMENTS
+    }
+    dest_store_requirements = {
+        r
+        for r in dest_repo.requirements
+        if r not in requirementsmod.WORKING_DIR_REQUIREMENTS
+    }
+    assert src_store_requirements == dest_store_requirements
+
+    with dest_repo.lock():
+        with src_repo.lock():
+            entries, totalfilesize = _v2_walk(
+                src_repo,
+                includes=None,
+                excludes=None,
+                includeobsmarkers=True,
+            )
+            src_vfs_map = _makemap(src_repo)
+            dest_vfs_map = _makemap(dest_repo)
+            progress = src_repo.ui.makeprogress(
+                topic=_(b'linking'),
+                total=len(entries),
+                unit=_(b'files'),
+            )
+            # copy  files
+            #
+            # We could copy the full file while the source repository is locked
+            # and the other one without the lock. However, in the linking case,
+            # this would also requires checks that nobody is appending any data
+            # to the files while we do the clone, so this is not done yet. We
+            # could do this blindly when copying files.
+            files = ((k, path, size) for k, path, ftype, size in entries)
+            hardlink = _copy_files(src_vfs_map, dest_vfs_map, files, progress)
+
+            # copy bookmarks over
+            src_book_vfs = bookmarks.bookmarksvfs(src_repo)
+            srcbookmarks = src_book_vfs.join(b'bookmarks')
+            dst_book_vfs = bookmarks.bookmarksvfs(dest_repo)
+            dstbookmarks = dst_book_vfs.join(b'bookmarks')
+            if os.path.exists(srcbookmarks):
+                util.copyfile(srcbookmarks, dstbookmarks)
+        progress.complete()
+        if hardlink:
+            msg = b'linked %d files\n'
+        else:
+            msg = b'copied %d files\n'
+        src_repo.ui.debug(msg % len(entries))
+
+        with dest_repo.transaction(b"localclone") as tr:
+            dest_repo.store.write(tr)
+
+        # clean up transaction file as they do not make sense
+        undo_files = [(dest_repo.svfs, b'undo.backupfiles')]
+        undo_files.extend(dest_repo.undofiles())
+        for undovfs, undofile in undo_files:
+            try:
+                undovfs.unlink(undofile)
+            except OSError as e:
+                if e.errno != errno.ENOENT:
+                    msg = _(b'error removing %s: %s\n')
+                    path = undovfs.join(undofile)
+                    e_msg = stringutil.forcebytestr(e)
+                    msg %= (path, e_msg)
+                    dest_repo.ui.warn(msg)

tests/test-clone.t

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

tests/test-empty.t

@@ -1,57 +1,58 b''
 Create an empty repo:
 
   $ hg init a
   $ cd a
 
 Try some commands:
 
   $ hg log
   $ hg grep wah
   [1]
   $ hg manifest
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 0 changesets with 0 changes to 0 files
 
 Check the basic files created:
 
   $ ls .hg
   00changelog.i
   cache
   requires
   store
   wcache
 
 Should be empty:
 
   $ ls .hg/store
 
 Poke at a clone:
 
   $ cd ..
   $ hg clone a b
   updating to branch default
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd b
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 0 changesets with 0 changes to 0 files
   $ ls .hg
   00changelog.i
   cache
+  dirstate
   hgrc
   requires
   store
   wcache
 
 Should be empty:
 
   $ ls .hg/store
 
   $ cd ..

tests/test-fncache.t

@@ -1,545 +1,549 b''
 #require repofncache
 
 An extension which will set fncache chunksize to 1 byte to make sure that logic
 does not break
 
   $ cat > chunksize.py <<EOF
   > from __future__ import absolute_import
   > from mercurial import store
   > store.fncache_chunksize = 1
   > EOF
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > chunksize = $TESTTMP/chunksize.py
   > EOF
 
 Init repo1:
 
   $ hg init repo1
   $ cd repo1
   $ echo "some text" > a
   $ hg add
   adding a
   $ hg ci -m first
   $ cat .hg/store/fncache | sort
   data/a.i
 
 Testing a.i/b:
 
   $ mkdir a.i
   $ echo "some other text" > a.i/b
   $ hg add
   adding a.i/b
   $ hg ci -m second
   $ cat .hg/store/fncache | sort
   data/a.i
   data/a.i.hg/b.i
 
 Testing a.i.hg/c:
 
   $ mkdir a.i.hg
   $ echo "yet another text" > a.i.hg/c
   $ hg add
   adding a.i.hg/c
   $ hg ci -m third
   $ cat .hg/store/fncache | sort
   data/a.i
   data/a.i.hg.hg/c.i
   data/a.i.hg/b.i
 
 Testing verify:
 
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 3 changesets with 3 changes to 3 files
 
   $ rm .hg/store/fncache
 
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
    warning: revlog 'data/a.i' not in fncache!
    warning: revlog 'data/a.i.hg/c.i' not in fncache!
    warning: revlog 'data/a.i/b.i' not in fncache!
   checked 3 changesets with 3 changes to 3 files
   3 warnings encountered!
   hint: run "hg debugrebuildfncache" to recover from corrupt fncache
 
 Follow the hint to make sure it works
 
   $ hg debugrebuildfncache
   adding data/a.i
   adding data/a.i.hg/c.i
   adding data/a.i/b.i
   3 items added, 0 removed from fncache
 
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 3 changesets with 3 changes to 3 files
 
   $ cd ..
 
 Non store repo:
 
   $ hg --config format.usestore=False init foo
   $ cd foo
   $ mkdir tst.d
   $ echo foo > tst.d/foo
   $ hg ci -Amfoo
   adding tst.d/foo
   $ find .hg | sort
   .hg
   .hg/00changelog.i
   .hg/00manifest.i
   .hg/cache
   .hg/cache/branch2-served
   .hg/cache/rbc-names-v1
   .hg/cache/rbc-revs-v1
   .hg/data
   .hg/data/tst.d.hg
   .hg/data/tst.d.hg/foo.i
   .hg/dirstate
   .hg/fsmonitor.state (fsmonitor !)
   .hg/last-message.txt
   .hg/phaseroots
   .hg/requires
   .hg/undo
   .hg/undo.backup.dirstate
   .hg/undo.backupfiles
   .hg/undo.bookmarks
   .hg/undo.branch
   .hg/undo.desc
   .hg/undo.dirstate
   .hg/undo.phaseroots
   .hg/wcache
   .hg/wcache/checkisexec (execbit !)
   .hg/wcache/checklink (symlink !)
   .hg/wcache/checklink-target (symlink !)
   .hg/wcache/manifestfulltextcache (reporevlogstore !)
   $ cd ..
 
 Non fncache repo:
 
   $ hg --config format.usefncache=False init bar
   $ cd bar
   $ mkdir tst.d
   $ echo foo > tst.d/Foo
   $ hg ci -Amfoo
   adding tst.d/Foo
   $ find .hg | sort
   .hg
   .hg/00changelog.i
   .hg/cache
   .hg/cache/branch2-served
   .hg/cache/rbc-names-v1
   .hg/cache/rbc-revs-v1
   .hg/dirstate
   .hg/fsmonitor.state (fsmonitor !)
   .hg/last-message.txt
   .hg/requires
   .hg/store
   .hg/store/00changelog.i
   .hg/store/00manifest.i
   .hg/store/data
   .hg/store/data/tst.d.hg
   .hg/store/data/tst.d.hg/_foo.i
   .hg/store/phaseroots
   .hg/store/undo
   .hg/store/undo.backupfiles
   .hg/store/undo.phaseroots
   .hg/undo.backup.dirstate
   .hg/undo.bookmarks
   .hg/undo.branch
   .hg/undo.desc
   .hg/undo.dirstate
   .hg/wcache
   .hg/wcache/checkisexec (execbit !)
   .hg/wcache/checklink (symlink !)
   .hg/wcache/checklink-target (symlink !)
   .hg/wcache/manifestfulltextcache (reporevlogstore !)
   $ cd ..
 
 Encoding of reserved / long paths in the store
 
   $ hg init r2
   $ cd r2
   $ cat <<EOF > .hg/hgrc
   > [ui]
   > portablefilenames = ignore
   > EOF
 
   $ hg import -q --bypass - <<EOF
   > # HG changeset patch
   > # User test
   > # Date 0 0
   > # Node ID 1c7a2f7cb77be1a0def34e4c7cabc562ad98fbd7
   > # Parent  0000000000000000000000000000000000000000
   > 1
   > 
   > diff --git a/12345678/12345678/12345678/12345678/12345678/12345678/12345678/12345/xxxxxxxxx-xxxxxxxxx-xxxxxxxxx-123456789-12.3456789-12345-ABCDEFGHIJKLMNOPRSTUVWXYZ-abcdefghjiklmnopqrstuvwxyz b/12345678/12345678/12345678/12345678/12345678/12345678/12345678/12345/xxxxxxxxx-xxxxxxxxx-xxxxxxxxx-123456789-12.3456789-12345-ABCDEFGHIJKLMNOPRSTUVWXYZ-abcdefghjiklmnopqrstuvwxyz
   > new file mode 100644
   > --- /dev/null
   > +++ b/12345678/12345678/12345678/12345678/12345678/12345678/12345678/12345/xxxxxxxxx-xxxxxxxxx-xxxxxxxxx-123456789-12.3456789-12345-ABCDEFGHIJKLMNOPRSTUVWXYZ-abcdefghjiklmnopqrstuvwxyz
   > @@ -0,0 +1,1 @@
   > +foo
   > diff --git a/AUX/SECOND/X.PRN/FOURTH/FI:FTH/SIXTH/SEVENTH/EIGHTH/NINETH/TENTH/ELEVENTH/LOREMIPSUM.TXT b/AUX/SECOND/X.PRN/FOURTH/FI:FTH/SIXTH/SEVENTH/EIGHTH/NINETH/TENTH/ELEVENTH/LOREMIPSUM.TXT
   > new file mode 100644
   > --- /dev/null
   > +++ b/AUX/SECOND/X.PRN/FOURTH/FI:FTH/SIXTH/SEVENTH/EIGHTH/NINETH/TENTH/ELEVENTH/LOREMIPSUM.TXT
   > @@ -0,0 +1,1 @@
   > +foo
   > diff --git a/Project Planning/Resources/AnotherLongDirectoryName/Followedbyanother/AndAnother/AndThenAnExtremelyLongFileName.txt b/Project Planning/Resources/AnotherLongDirectoryName/Followedbyanother/AndAnother/AndThenAnExtremelyLongFileName.txt
   > new file mode 100644
   > --- /dev/null
   > +++ b/Project Planning/Resources/AnotherLongDirectoryName/Followedbyanother/AndAnother/AndThenAnExtremelyLongFileName.txt	
   > @@ -0,0 +1,1 @@
   > +foo
   > diff --git a/bla.aux/prn/PRN/lpt/com3/nul/coma/foo.NUL/normal.c b/bla.aux/prn/PRN/lpt/com3/nul/coma/foo.NUL/normal.c
   > new file mode 100644
   > --- /dev/null
   > +++ b/bla.aux/prn/PRN/lpt/com3/nul/coma/foo.NUL/normal.c
   > @@ -0,0 +1,1 @@
   > +foo
   > diff --git a/enterprise/openesbaddons/contrib-imola/corba-bc/netbeansplugin/wsdlExtension/src/main/java/META-INF/services/org.netbeans.modules.xml.wsdl.bindingsupport.spi.ExtensibilityElementTemplateProvider b/enterprise/openesbaddons/contrib-imola/corba-bc/netbeansplugin/wsdlExtension/src/main/java/META-INF/services/org.netbeans.modules.xml.wsdl.bindingsupport.spi.ExtensibilityElementTemplateProvider
   > new file mode 100644
   > --- /dev/null
   > +++ b/enterprise/openesbaddons/contrib-imola/corba-bc/netbeansplugin/wsdlExtension/src/main/java/META-INF/services/org.netbeans.modules.xml.wsdl.bindingsupport.spi.ExtensibilityElementTemplateProvider
   > @@ -0,0 +1,1 @@
   > +foo
   > EOF
 
   $ find .hg/store -name *.i  | sort
   .hg/store/00changelog.i
   .hg/store/00manifest.i
   .hg/store/data/bla.aux/pr~6e/_p_r_n/lpt/co~6d3/nu~6c/coma/foo._n_u_l/normal.c.i
   .hg/store/dh/12345678/12345678/12345678/12345678/12345678/12345678/12345678/12345/xxxxxx168e07b38e65eff86ab579afaaa8e30bfbe0f35f.i
   .hg/store/dh/au~78/second/x.prn/fourth/fi~3afth/sixth/seventh/eighth/nineth/tenth/loremia20419e358ddff1bf8751e38288aff1d7c32ec05.i
   .hg/store/dh/enterpri/openesba/contrib-/corba-bc/netbeans/wsdlexte/src/main/java/org.net7018f27961fdf338a598a40c4683429e7ffb9743.i
   .hg/store/dh/project_/resource/anotherl/followed/andanoth/andthenanextremelylongfilename0d8e1f4187c650e2f1fdca9fd90f786bc0976b6b.i
 
   $ cd ..
 
 Aborting lock does not prevent fncache writes
 
   $ cat > exceptionext.py <<EOF
   > from __future__ import absolute_import
   > import os
   > from mercurial import commands, error, extensions
   > 
   > def lockexception(orig, vfs, lockname, wait, releasefn, *args, **kwargs):
   >     def releasewrap():
   >         l.held = False # ensure __del__ is a noop
   >         raise error.Abort(b"forced lock failure")
   >     l = orig(vfs, lockname, wait, releasewrap, *args, **kwargs)
   >     return l
   > 
   > def reposetup(ui, repo):
   >     extensions.wrapfunction(repo, '_lock', lockexception)
   > 
   > cmdtable = {}
   > 
   > # wrap "commit" command to prevent wlock from being '__del__()'-ed
   > # at the end of dispatching (for intentional "forced lcok failure")
   > def commitwrap(orig, ui, repo, *pats, **opts):
   >     repo = repo.unfiltered() # to use replaced repo._lock certainly
   >     wlock = repo.wlock()
   >     try:
   >         return orig(ui, repo, *pats, **opts)
   >     finally:
   >         # multiple 'relase()' is needed for complete releasing wlock,
   >         # because "forced" abort at last releasing store lock
   >         # prevents wlock from being released at same 'lockmod.release()'
   >         for i in range(wlock.held):
   >             wlock.release()
   > 
   > def extsetup(ui):
   >     extensions.wrapcommand(commands.table, b"commit", commitwrap)
   > EOF
   $ extpath=`pwd`/exceptionext.py
   $ hg init fncachetxn
   $ cd fncachetxn
   $ printf "[extensions]\nexceptionext=$extpath\n" >> .hg/hgrc
   $ touch y
   $ hg ci -qAm y
   abort: forced lock failure
   [255]
   $ cat .hg/store/fncache
   data/y.i
 
 Aborting transaction prevents fncache change
 
   $ cat > ../exceptionext.py <<EOF
   > from __future__ import absolute_import
   > import os
   > from mercurial import commands, error, extensions, localrepo
   > 
   > def wrapper(orig, self, *args, **kwargs):
   >     tr = orig(self, *args, **kwargs)
   >     def fail(tr):
   >         raise error.Abort(b"forced transaction failure")
   >     # zzz prefix to ensure it sorted after store.write
   >     tr.addfinalize(b'zzz-forcefails', fail)
   >     return tr
   > 
   > def uisetup(ui):
   >     extensions.wrapfunction(
   >         localrepo.localrepository, b'transaction', wrapper)
   > 
   > cmdtable = {}
   > 
   > EOF
 
 Clean cached version
   $ rm -f "${extpath}c"
   $ rm -Rf "`dirname $extpath`/__pycache__"
 
   $ touch z
   $ hg ci -qAm z
   transaction abort!
   rollback completed
   abort: forced transaction failure
   [255]
   $ cat .hg/store/fncache
   data/y.i
 
 Aborted transactions can be recovered later
 
   $ cat > ../exceptionext.py <<EOF
   > from __future__ import absolute_import
   > import os
   > from mercurial import (
   >   commands,
   >   error,
   >   extensions,
   >   localrepo,
   >   transaction,
   > )
   > 
   > def trwrapper(orig, self, *args, **kwargs):
   >     tr = orig(self, *args, **kwargs)
   >     def fail(tr):
   >         raise error.Abort(b"forced transaction failure")
   >     # zzz prefix to ensure it sorted after store.write
   >     tr.addfinalize(b'zzz-forcefails', fail)
   >     return tr
   > 
   > def abortwrapper(orig, self, *args, **kwargs):
   >     raise error.Abort(b"forced transaction failure")
   > 
   > def uisetup(ui):
   >     extensions.wrapfunction(localrepo.localrepository, 'transaction',
   >                             trwrapper)
   >     extensions.wrapfunction(transaction.transaction, '_abort',
   >                             abortwrapper)
   > 
   > cmdtable = {}
   > 
   > EOF
 
 Clean cached versions
   $ rm -f "${extpath}c"
   $ rm -Rf "`dirname $extpath`/__pycache__"
 
   $ hg up -q 1
   $ touch z
   $ hg ci -qAm z 2>/dev/null
   [255]
   $ cat .hg/store/fncache | sort
   data/y.i
   data/z.i
   $ hg recover --verify
   rolling back interrupted transaction
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 1 changesets with 1 changes to 1 files
   $ cat .hg/store/fncache
   data/y.i
 
   $ cd ..
 
 debugrebuildfncache does nothing unless repo has fncache requirement
 
   $ hg --config format.usefncache=false init nofncache
   $ cd nofncache
   $ hg debugrebuildfncache
   (not rebuilding fncache because repository does not support fncache)
 
   $ cd ..
 
 debugrebuildfncache works on empty repository
 
   $ hg init empty
   $ cd empty
   $ hg debugrebuildfncache
   fncache already up to date
   $ cd ..
 
 debugrebuildfncache on an up to date repository no-ops
 
   $ hg init repo
   $ cd repo
   $ echo initial > foo
   $ echo initial > .bar
   $ hg commit -A -m initial
   adding .bar
   adding foo
 
   $ cat .hg/store/fncache | sort
   data/.bar.i
   data/foo.i
 
   $ hg debugrebuildfncache
   fncache already up to date
 
 debugrebuildfncache restores deleted fncache file
 
   $ rm -f .hg/store/fncache
   $ hg debugrebuildfncache
   adding data/.bar.i
   adding data/foo.i
   2 items added, 0 removed from fncache
 
   $ cat .hg/store/fncache | sort
   data/.bar.i
   data/foo.i
 
 Rebuild after rebuild should no-op
 
   $ hg debugrebuildfncache
   fncache already up to date
 
 A single missing file should get restored, an extra file should be removed
 
   $ cat > .hg/store/fncache << EOF
   > data/foo.i
   > data/bad-entry.i
   > EOF
 
   $ hg debugrebuildfncache
   removing data/bad-entry.i
   adding data/.bar.i
   1 items added, 1 removed from fncache
 
   $ cat .hg/store/fncache | sort
   data/.bar.i
   data/foo.i
 
 debugrebuildfncache recovers from truncated line in fncache
 
   $ printf a > .hg/store/fncache
   $ hg debugrebuildfncache
   fncache does not ends with a newline
   adding data/.bar.i
   adding data/foo.i
   2 items added, 0 removed from fncache
 
   $ cat .hg/store/fncache | sort
   data/.bar.i
   data/foo.i
 
   $ cd ..
 
 Try a simple variation without dotencode to ensure fncache is ignorant of encoding
 
   $ hg --config format.dotencode=false init nodotencode
   $ cd nodotencode
   $ echo initial > foo
   $ echo initial > .bar
   $ hg commit -A -m initial
   adding .bar
   adding foo
 
   $ cat .hg/store/fncache | sort
   data/.bar.i
   data/foo.i
 
   $ rm .hg/store/fncache
   $ hg debugrebuildfncache
   adding data/.bar.i
   adding data/foo.i
   2 items added, 0 removed from fncache
 
   $ cat .hg/store/fncache | sort
   data/.bar.i
   data/foo.i
 
   $ cd ..
 
 In repositories that have accumulated a large number of files over time, the
 fncache file is going to be large. If we possibly can avoid loading it, so much the better.
 The cache should not loaded when committing changes to existing files, or when unbundling
 changesets that only contain changes to existing files:
 
   $ cat > fncacheloadwarn.py << EOF
   > from __future__ import absolute_import
   > from mercurial import extensions, localrepo
   > 
   > def extsetup(ui):
   >     def wrapstore(orig, requirements, *args):
   >         store = orig(requirements, *args)
   >         if b'store' in requirements and b'fncache' in requirements:
   >             instrumentfncachestore(store, ui)
   >         return store
   >     extensions.wrapfunction(localrepo, 'makestore', wrapstore)
   > 
   > def instrumentfncachestore(fncachestore, ui):
   >     class instrumentedfncache(type(fncachestore.fncache)):
   >         def _load(self):
   >             ui.warn(b'fncache load triggered!\n')
   >             super(instrumentedfncache, self)._load()
   >     fncachestore.fncache.__class__ = instrumentedfncache
   > EOF
 
   $ fncachextpath=`pwd`/fncacheloadwarn.py
   $ hg init nofncacheload
   $ cd nofncacheload
   $ printf "[extensions]\nfncacheloadwarn=$fncachextpath\n" >> .hg/hgrc
 
 A new file should trigger a load, as we'd want to update the fncache set in that case:
 
   $ touch foo
   $ hg ci -qAm foo
   fncache load triggered!
 
 But modifying that file should not:
 
   $ echo bar >> foo
   $ hg ci -qm foo
 
 If a transaction has been aborted, the zero-size truncated index file will
 not prevent the fncache from being loaded; rather than actually abort
 a transaction, we simulate the situation by creating a zero-size index file:
 
   $ touch .hg/store/data/bar.i
   $ touch bar
   $ hg ci -qAm bar
   fncache load triggered!
 
 Unbundling should follow the same rules; existing files should not cause a load:
 
+(loading during the clone is expected)
   $ hg clone -q . tobundle
+  fncache load triggered!
+  fncache load triggered!
+
   $ echo 'new line' > tobundle/bar
   $ hg -R tobundle ci -qm bar
   $ hg -R tobundle bundle -q barupdated.hg
   $ hg unbundle -q barupdated.hg
 
 but adding new files should:
 
   $ touch tobundle/newfile
   $ hg -R tobundle ci -qAm newfile
   $ hg -R tobundle bundle -q newfile.hg
   $ hg unbundle -q newfile.hg
   fncache load triggered!
 
   $ cd ..

tests/test-hardlinks.t

@@ -1,445 +1,445 b''
 #require hardlink reporevlogstore
 
   $ cat > nlinks.py <<EOF
   > from __future__ import print_function
   > import sys
   > from mercurial import pycompat, util
   > for f in sorted(sys.stdin.readlines()):
   >     f = f[:-1]
   >     print(util.nlinks(pycompat.fsencode(f)), f)
   > EOF
 
   $ nlinksdir()
   > {
   >     find "$@" -type f | "$PYTHON" $TESTTMP/nlinks.py
   > }
 
 Some implementations of cp can't create hardlinks (replaces 'cp -al' on Linux):
 
   $ cat > linkcp.py <<EOF
   > from __future__ import absolute_import
   > import sys
   > from mercurial import pycompat, util
   > util.copyfiles(pycompat.fsencode(sys.argv[1]),
   >                pycompat.fsencode(sys.argv[2]), hardlink=True)
   > EOF
 
   $ linkcp()
   > {
   >     "$PYTHON" $TESTTMP/linkcp.py $1 $2
   > }
 
 Prepare repo r1:
 
   $ hg init r1
   $ cd r1
 
   $ echo c1 > f1
   $ hg add f1
   $ hg ci -m0
 
   $ mkdir d1
   $ cd d1
   $ echo c2 > f2
   $ hg add f2
   $ hg ci -m1
   $ cd ../..
 
   $ nlinksdir r1/.hg/store
   1 r1/.hg/store/00changelog.i
   1 r1/.hg/store/00manifest.i
   1 r1/.hg/store/data/d1/f2.i
   1 r1/.hg/store/data/f1.i
   1 r1/.hg/store/fncache (repofncache !)
   1 r1/.hg/store/phaseroots
   1 r1/.hg/store/undo
   1 r1/.hg/store/undo.backup.fncache (repofncache !)
   1 r1/.hg/store/undo.backupfiles
   1 r1/.hg/store/undo.phaseroots
 
 
 Create hardlinked clone r2:
 
   $ hg clone -U --debug r1 r2 --config progress.debug=true
-  linking: 1 files
-  linking: 2 files
-  linking: 3 files
-  linking: 4 files
-  linking: 5 files
-  linking: 6 files
-  linking: 7 files
+  linking: 1/7 files (14.29%)
+  linking: 2/7 files (28.57%)
+  linking: 3/7 files (42.86%)
+  linking: 4/7 files (57.14%)
+  linking: 5/7 files (71.43%)
+  linking: 6/7 files (85.71%)
+  linking: 7/7 files (100.00%)
   linked 7 files
   updating the branch cache
 
 Create non-hardlinked clone r3:
 
   $ hg clone --pull r1 r3
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   new changesets 40d85e9847f2:7069c422939c
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 
 Repos r1 and r2 should now contain hardlinked files:
 
   $ nlinksdir r1/.hg/store
   2 r1/.hg/store/00changelog.i
   2 r1/.hg/store/00manifest.i
   2 r1/.hg/store/data/d1/f2.i
   2 r1/.hg/store/data/f1.i
-  2 r1/.hg/store/fncache (repofncache !)
+  1 r1/.hg/store/fncache (repofncache !)
   1 r1/.hg/store/phaseroots
   1 r1/.hg/store/undo
   1 r1/.hg/store/undo.backup.fncache (repofncache !)
   1 r1/.hg/store/undo.backupfiles
   1 r1/.hg/store/undo.phaseroots
 
   $ nlinksdir r2/.hg/store
   2 r2/.hg/store/00changelog.i
   2 r2/.hg/store/00manifest.i
   2 r2/.hg/store/data/d1/f2.i
   2 r2/.hg/store/data/f1.i
-  2 r2/.hg/store/fncache (repofncache !)
+  1 r2/.hg/store/fncache (repofncache !)
 
 Repo r3 should not be hardlinked:
 
   $ nlinksdir r3/.hg/store
   1 r3/.hg/store/00changelog.i
   1 r3/.hg/store/00manifest.i
   1 r3/.hg/store/data/d1/f2.i
   1 r3/.hg/store/data/f1.i
   1 r3/.hg/store/fncache (repofncache !)
   1 r3/.hg/store/phaseroots
   1 r3/.hg/store/undo
   1 r3/.hg/store/undo.backupfiles
   1 r3/.hg/store/undo.phaseroots
 
 
 Create a non-inlined filelog in r3:
 
   $ cd r3/d1
   >>> f = open('data1', 'wb')
   >>> for x in range(10000):
   ...     f.write(b"%d\n" % x) and None
   >>> f.close()
   $ for j in 0 1 2 3 4 5 6 7 8 9; do
   >   cat data1 >> f2
   >   hg commit -m$j
   > done
   $ cd ../..
 
   $ nlinksdir r3/.hg/store
   1 r3/.hg/store/00changelog.i
   1 r3/.hg/store/00manifest.i
   1 r3/.hg/store/data/d1/f2.d
   1 r3/.hg/store/data/d1/f2.i
   1 r3/.hg/store/data/f1.i
   1 r3/.hg/store/fncache (repofncache !)
   1 r3/.hg/store/phaseroots
   1 r3/.hg/store/undo
   1 r3/.hg/store/undo.backup.fncache (repofncache !)
   1 r3/.hg/store/undo.backup.phaseroots
   1 r3/.hg/store/undo.backupfiles
   1 r3/.hg/store/undo.phaseroots
 
 Push to repo r1 should break up most hardlinks in r2:
 
   $ hg -R r2 verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 2 changesets with 2 changes to 2 files
 
   $ cd r3
   $ hg push
   pushing to $TESTTMP/r1
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 10 changesets with 10 changes to 1 files
 
   $ cd ..
 
   $ nlinksdir r2/.hg/store
   1 r2/.hg/store/00changelog.i
   1 r2/.hg/store/00manifest.i
   1 r2/.hg/store/data/d1/f2.i
   2 r2/.hg/store/data/f1.i
   [12] r2/\.hg/store/fncache (re) (repofncache !)
 
 #if hardlink-whitelisted repofncache
   $ nlinksdir r2/.hg/store/fncache
-  2 r2/.hg/store/fncache
+  1 r2/.hg/store/fncache
 #endif
 
   $ hg -R r2 verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 2 changesets with 2 changes to 2 files
 
 
   $ cd r1
   $ hg up
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Committing a change to f1 in r1 must break up hardlink f1.i in r2:
 
   $ echo c1c1 >> f1
   $ hg ci -m00
   $ cd ..
 
   $ nlinksdir r2/.hg/store
   1 r2/.hg/store/00changelog.i
   1 r2/.hg/store/00manifest.i
   1 r2/.hg/store/data/d1/f2.i
   1 r2/.hg/store/data/f1.i
-  [12] r2/\.hg/store/fncache (re) (repofncache !)
+  1 r2/.hg/store/fncache (repofncache !)
 
 #if hardlink-whitelisted repofncache
   $ nlinksdir r2/.hg/store/fncache
-  2 r2/.hg/store/fncache
+  1 r2/.hg/store/fncache
 #endif
 
 Create a file which exec permissions we will change
   $ cd r3
   $ echo "echo hello world" > f3
   $ hg add f3
   $ hg ci -mf3
   $ cd ..
 
   $ cd r3
   $ hg tip --template '{rev}:{node|short}\n'
   12:d3b77733a28a
   $ echo bla > f1
   $ chmod +x f3
   $ hg ci -m1
   $ cd ..
 
 Create hardlinked copy r4 of r3 (on Linux, we would call 'cp -al'):
 
   $ linkcp r3 r4
 
 'checklink' is produced by hardlinking a symlink, which is undefined whether
 the symlink should be followed or not. It does behave differently on Linux and
 BSD. Just remove it so the test pass on both platforms.
 
   $ rm -f r4/.hg/wcache/checklink
 
 r4 has hardlinks in the working dir (not just inside .hg):
 
   $ nlinksdir r4
   2 r4/.hg/00changelog.i
   2 r4/.hg/branch
   2 r4/.hg/cache/branch2-base
   2 r4/.hg/cache/branch2-immutable
   2 r4/.hg/cache/branch2-served
   2 r4/.hg/cache/branch2-served.hidden
   2 r4/.hg/cache/branch2-visible
   2 r4/.hg/cache/branch2-visible-hidden
   2 r4/.hg/cache/rbc-names-v1
   2 r4/.hg/cache/rbc-revs-v1
   2 r4/.hg/cache/tags2
   2 r4/.hg/cache/tags2-served
   2 r4/.hg/dirstate
   2 r4/.hg/fsmonitor.state (fsmonitor !)
   2 r4/.hg/hgrc
   2 r4/.hg/last-message.txt
   2 r4/.hg/requires
   2 r4/.hg/store/00changelog.i
   2 r4/.hg/store/00manifest.i
   2 r4/.hg/store/data/d1/f2.d
   2 r4/.hg/store/data/d1/f2.i
   2 r4/.hg/store/data/f1.i
   2 r4/.hg/store/data/f3.i
   2 r4/.hg/store/fncache (repofncache !)
   2 r4/.hg/store/phaseroots
   2 r4/.hg/store/undo
   2 r4/.hg/store/undo.backup.fncache (repofncache !)
   2 r4/.hg/store/undo.backup.phaseroots
   2 r4/.hg/store/undo.backupfiles
   2 r4/.hg/store/undo.phaseroots
   [24] r4/\.hg/undo\.backup\.dirstate (re)
   2 r4/.hg/undo.bookmarks
   2 r4/.hg/undo.branch
   2 r4/.hg/undo.desc
   [24] r4/\.hg/undo\.dirstate (re)
   2 r4/.hg/wcache/checkisexec (execbit !)
   2 r4/.hg/wcache/checklink-target (symlink !)
   2 r4/.hg/wcache/checknoexec (execbit !)
   2 r4/.hg/wcache/manifestfulltextcache (reporevlogstore !)
   2 r4/d1/data1
   2 r4/d1/f2
   2 r4/f1
   2 r4/f3
 
 Update back to revision 12 in r4 should break hardlink of file f1 and f3:
 #if hardlink-whitelisted
   $ nlinksdir r4/.hg/undo.backup.dirstate r4/.hg/undo.dirstate
   4 r4/.hg/undo.backup.dirstate
   4 r4/.hg/undo.dirstate
 #endif
 
 
   $ hg -R r4 up 12
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved (execbit !)
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved (no-execbit !)
 
   $ nlinksdir r4
   2 r4/.hg/00changelog.i
   1 r4/.hg/branch
   2 r4/.hg/cache/branch2-base
   2 r4/.hg/cache/branch2-immutable
   2 r4/.hg/cache/branch2-served
   2 r4/.hg/cache/branch2-served.hidden
   2 r4/.hg/cache/branch2-visible
   2 r4/.hg/cache/branch2-visible-hidden
   2 r4/.hg/cache/rbc-names-v1
   2 r4/.hg/cache/rbc-revs-v1
   2 r4/.hg/cache/tags2
   2 r4/.hg/cache/tags2-served
   1 r4/.hg/dirstate
   1 r4/.hg/fsmonitor.state (fsmonitor !)
   2 r4/.hg/hgrc
   2 r4/.hg/last-message.txt
   2 r4/.hg/requires
   2 r4/.hg/store/00changelog.i
   2 r4/.hg/store/00manifest.i
   2 r4/.hg/store/data/d1/f2.d
   2 r4/.hg/store/data/d1/f2.i
   2 r4/.hg/store/data/f1.i
   2 r4/.hg/store/data/f3.i
   2 r4/.hg/store/fncache
   2 r4/.hg/store/phaseroots
   2 r4/.hg/store/undo
   2 r4/.hg/store/undo.backup.fncache (repofncache !)
   2 r4/.hg/store/undo.backup.phaseroots
   2 r4/.hg/store/undo.backupfiles
   2 r4/.hg/store/undo.phaseroots
   [24] r4/\.hg/undo\.backup\.dirstate (re)
   2 r4/.hg/undo.bookmarks
   2 r4/.hg/undo.branch
   2 r4/.hg/undo.desc
   [24] r4/\.hg/undo\.dirstate (re)
   2 r4/.hg/wcache/checkisexec (execbit !)
   2 r4/.hg/wcache/checklink-target (symlink !)
   2 r4/.hg/wcache/checknoexec (execbit !)
   1 r4/.hg/wcache/manifestfulltextcache (reporevlogstore !)
   2 r4/d1/data1
   2 r4/d1/f2
   1 r4/f1
   1 r4/f3 (execbit !)
   2 r4/f3 (no-execbit !)
 
 #if hardlink-whitelisted
   $ nlinksdir r4/.hg/undo.backup.dirstate r4/.hg/undo.dirstate
   4 r4/.hg/undo.backup.dirstate
   4 r4/.hg/undo.dirstate
 #endif
 
 Test hardlinking outside hg:
 
   $ mkdir x
   $ echo foo > x/a
 
   $ linkcp x y
   $ echo bar >> y/a
 
 No diff if hardlink:
 
   $ diff x/a y/a
 
 Test mq hardlinking:
 
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "mq=" >> $HGRCPATH
 
   $ hg init a
   $ cd a
 
   $ hg qimport -n foo - << EOF
   > # HG changeset patch
   > # Date 1 0
   > diff -r 2588a8b53d66 a
   > --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   > +++ b/a	Wed Jul 23 15:54:29 2008 +0200
   > @@ -0,0 +1,1 @@
   > +a
   > EOF
   adding foo to series file
 
   $ hg qpush
   applying foo
   now at: foo
 
   $ cd ..
   $ linkcp a b
   $ cd b
 
   $ hg qimport -n bar - << EOF
   > # HG changeset patch
   > # Date 2 0
   > diff -r 2588a8b53d66 a
   > --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   > +++ b/b	Wed Jul 23 15:54:29 2008 +0200
   > @@ -0,0 +1,1 @@
   > +b
   > EOF
   adding bar to series file
 
   $ hg qpush
   applying bar
   now at: bar
 
   $ cat .hg/patches/status
   430ed4828a74fa4047bc816a25500f7472ab4bfe:foo
   4e7abb4840c46a910f6d7b4d3c3fc7e5209e684c:bar
 
   $ cat .hg/patches/series
   foo
   bar
 
   $ cat ../a/.hg/patches/status
   430ed4828a74fa4047bc816a25500f7472ab4bfe:foo
 
   $ cat ../a/.hg/patches/series
   foo
 
 Test tags hardlinking:
 
   $ hg qdel -r qbase:qtip
   patch foo finalized without changeset message
   patch bar finalized without changeset message
 
   $ hg tag -l lfoo
   $ hg tag foo
 
   $ cd ..
   $ linkcp b c
   $ cd c
 
   $ hg tag -l -r 0 lbar
   $ hg tag -r 0 bar
 
   $ cat .hgtags
   4e7abb4840c46a910f6d7b4d3c3fc7e5209e684c foo
   430ed4828a74fa4047bc816a25500f7472ab4bfe bar
 
   $ cat .hg/localtags
   4e7abb4840c46a910f6d7b4d3c3fc7e5209e684c lfoo
   430ed4828a74fa4047bc816a25500f7472ab4bfe lbar
 
   $ cat ../b/.hgtags
   4e7abb4840c46a910f6d7b4d3c3fc7e5209e684c foo
 
   $ cat ../b/.hg/localtags
   4e7abb4840c46a910f6d7b4d3c3fc7e5209e684c lfoo
 
   $ cd ..

tests/test-subrepo-deep-nested-change.t

@@ -1,1182 +1,1170 b''
   $ cat >> $HGRCPATH <<EOF
   > [extdiff]
   > # for portability:
   > pdiff = sh "$RUNTESTDIR/pdiff"
   > [progress]
   > disable=False
   > assume-tty = 1
   > delay = 0
   > # set changedelay really large so we don't see nested topics
   > changedelay = 30000
   > format = topic bar number
   > refresh = 0
   > width = 60
   > EOF
 
 Preparing the subrepository 'sub2'
 
   $ hg init sub2
   $ echo sub2 > sub2/sub2
   $ hg add -R sub2
   adding sub2/sub2
   $ hg commit -R sub2 -m "sub2 import"
 
 Preparing the 'sub1' repo which depends on the subrepo 'sub2'
 
   $ hg init sub1
   $ echo sub1 > sub1/sub1
   $ echo "sub2 = ../sub2" > sub1/.hgsub
   $ hg clone sub2 sub1/sub2
   \r (no-eol) (esc)
-  linking [ <=>                                           ] 1\r (no-eol) (esc)
-  linking [  <=>                                          ] 2\r (no-eol) (esc)
-  linking [   <=>                                         ] 3\r (no-eol) (esc)
-  linking [    <=>                                        ] 4\r (no-eol) (esc)
-  linking [     <=>                                       ] 5\r (no-eol) (esc)
-  linking [      <=>                                      ] 6\r (no-eol) (esc)
+  linking [======>                                      ] 1/6\r (no-eol) (esc)
+  linking [==============>                              ] 2/6\r (no-eol) (esc)
+  linking [=====================>                       ] 3/6\r (no-eol) (esc)
+  linking [=============================>               ] 4/6\r (no-eol) (esc)
+  linking [====================================>        ] 5/6\r (no-eol) (esc)
+  linking [============================================>] 6/6\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   updating [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg add -R sub1
   adding sub1/.hgsub
   adding sub1/sub1
   $ hg commit -R sub1 -m "sub1 import"
 
 Preparing the 'main' repo which depends on the subrepo 'sub1'
 
   $ hg init main
   $ echo main > main/main
   $ echo "sub1 = ../sub1" > main/.hgsub
   $ hg clone sub1 main/sub1
   \r (no-eol) (esc)
-  linking [ <=>                                           ] 1\r (no-eol) (esc)
-  linking [  <=>                                          ] 2\r (no-eol) (esc)
-  linking [   <=>                                         ] 3\r (no-eol) (esc)
-  linking [    <=>                                        ] 4\r (no-eol) (esc)
-  linking [     <=>                                       ] 5\r (no-eol) (esc)
-  linking [      <=>                                      ] 6\r (no-eol) (esc)
-  linking [       <=>                                     ] 7\r (no-eol) (esc)
-  linking [        <=>                                    ] 8\r (no-eol) (esc)
-  linking [         <=>                                   ] 9\r (no-eol) (esc) (reposimplestore !)
-  linking [          <=>                                 ] 10\r (no-eol) (esc) (reposimplestore !)
+  linking [====>                                        ] 1/8\r (no-eol) (esc)
+  linking [==========>                                  ] 2/8\r (no-eol) (esc)
+  linking [===============>                             ] 3/8\r (no-eol) (esc)
+  linking [=====================>                       ] 4/8\r (no-eol) (esc)
+  linking [===========================>                 ] 5/8\r (no-eol) (esc)
+  linking [================================>            ] 6/8\r (no-eol) (esc)
+  linking [======================================>      ] 7/8\r (no-eol) (esc)
+  linking [============================================>] 8/8\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   updating [===========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
-  linking [ <=>                                           ] 1\r (no-eol) (esc)
-  linking [  <=>                                          ] 2\r (no-eol) (esc)
-  linking [   <=>                                         ] 3\r (no-eol) (esc)
-  linking [    <=>                                        ] 4\r (no-eol) (esc)
-  linking [     <=>                                       ] 5\r (no-eol) (esc)
-  linking [      <=>                                      ] 6\r (no-eol) (esc)
+  linking [======>                                      ] 1/6\r (no-eol) (esc)
+  linking [==============>                              ] 2/6\r (no-eol) (esc)
+  linking [=====================>                       ] 3/6\r (no-eol) (esc)
+  linking [=============================>               ] 4/6\r (no-eol) (esc)
+  linking [====================================>        ] 5/6\r (no-eol) (esc)
+  linking [============================================>] 6/6\r (no-eol) (esc)
   updating [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   updating to branch default
   cloning subrepo sub2 from $TESTTMP/sub2
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg add -R main
   adding main/.hgsub
   adding main/main
   $ hg commit -R main -m "main import"
 
 #if serve
 
 Unfortunately, subrepos not at their nominal location cannot be cloned.  But
 they are still served from their location within the local repository.  The only
 reason why 'main' can be cloned via the filesystem is because 'sub1' and 'sub2'
 are also available as siblings of 'main'.
 
   $ hg serve -R main --debug -S -p $HGPORT -d --pid-file=hg1.pid -E error.log -A access.log
   adding  = $TESTTMP/main
   adding sub1 = $TESTTMP/main/sub1
   adding sub1/sub2 = $TESTTMP/main/sub1/sub2
   listening at http://*:$HGPORT/ (bound to *:$HGPORT) (glob) (?)
   adding  = $TESTTMP/main (?)
   adding sub1 = $TESTTMP/main/sub1 (?)
   adding sub1/sub2 = $TESTTMP/main/sub1/sub2 (?)
   $ cat hg1.pid >> $DAEMON_PIDS
 
   $ hg clone http://localhost:$HGPORT httpclone --config progress.disable=True
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 3 changes to 3 files
   new changesets 7f491f53a367
   updating to branch default
   cloning subrepo sub1 from http://localhost:$HGPORT/../sub1
   abort: HTTP Error 404: Not Found
   [100]
 
   $ cat access.log
   * "GET /?cmd=capabilities HTTP/1.1" 200 - (glob)
   * "GET /?cmd=batch HTTP/1.1" 200 - * (glob)
   * "GET /?cmd=getbundle HTTP/1.1" 200 - * (glob)
   * "GET /../sub1?cmd=capabilities HTTP/1.1" 404 - (glob)
   $ cat error.log
 
   $ killdaemons.py
   $ rm hg1.pid error.log access.log
 #endif
 
 Cleaning both repositories, just as a clone -U
 
   $ hg up -C -R sub2 null
   \r (no-eol) (esc)
   updating [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg up -C -R sub1 null
   \r (no-eol) (esc)
   updating [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   updating [===========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   0 files updated, 0 files merged, 3 files removed, 0 files unresolved
   $ hg up -C -R main null
   \r (no-eol) (esc)
   updating [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   updating [===========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   updating [===========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   0 files updated, 0 files merged, 3 files removed, 0 files unresolved
   $ rm -rf main/sub1
   $ rm -rf sub1/sub2
 
 Clone main
 
   $ hg --config extensions.largefiles= clone main cloned
   \r (no-eol) (esc)
-  linking [ <=>                                           ] 1\r (no-eol) (esc)
-  linking [  <=>                                          ] 2\r (no-eol) (esc)
-  linking [   <=>                                         ] 3\r (no-eol) (esc)
-  linking [    <=>                                        ] 4\r (no-eol) (esc)
-  linking [     <=>                                       ] 5\r (no-eol) (esc)
-  linking [      <=>                                      ] 6\r (no-eol) (esc)
-  linking [       <=>                                     ] 7\r (no-eol) (esc)
-  linking [        <=>                                    ] 8\r (no-eol) (esc)
-  linking [         <=>                                   ] 9\r (no-eol) (esc) (reposimplestore !)
-  linking [          <=>                                 ] 10\r (no-eol) (esc) (reposimplestore !)
+  linking [====>                                        ] 1/8\r (no-eol) (esc)
+  linking [==========>                                  ] 2/8\r (no-eol) (esc)
+  linking [===============>                             ] 3/8\r (no-eol) (esc)
+  linking [=====================>                       ] 4/8\r (no-eol) (esc)
+  linking [===========================>                 ] 5/8\r (no-eol) (esc)
+  linking [================================>            ] 6/8\r (no-eol) (esc)
+  linking [======================================>      ] 7/8\r (no-eol) (esc)
+  linking [============================================>] 8/8\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   updating [===========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
-  linking [ <=>                                           ] 1\r (no-eol) (esc)
-  linking [  <=>                                          ] 2\r (no-eol) (esc)
-  linking [   <=>                                         ] 3\r (no-eol) (esc)
-  linking [    <=>                                        ] 4\r (no-eol) (esc)
-  linking [     <=>                                       ] 5\r (no-eol) (esc)
-  linking [      <=>                                      ] 6\r (no-eol) (esc)
-  linking [       <=>                                     ] 7\r (no-eol) (esc)
-  linking [        <=>                                    ] 8\r (no-eol) (esc)
-  linking [         <=>                                   ] 9\r (no-eol) (esc) (reposimplestore !)
-  linking [          <=>                                 ] 10\r (no-eol) (esc) (reposimplestore !)
+  linking [====>                                        ] 1/8\r (no-eol) (esc)
+  linking [==========>                                  ] 2/8\r (no-eol) (esc)
+  linking [===============>                             ] 3/8\r (no-eol) (esc)
+  linking [=====================>                       ] 4/8\r (no-eol) (esc)
+  linking [===========================>                 ] 5/8\r (no-eol) (esc)
+  linking [================================>            ] 6/8\r (no-eol) (esc)
+  linking [======================================>      ] 7/8\r (no-eol) (esc)
+  linking [============================================>] 8/8\r (no-eol) (esc)
   updating [===========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
-  linking [         <=>                                   ] 1\r (no-eol) (esc) (reporevlogstore !)
-  linking [          <=>                                  ] 2\r (no-eol) (esc) (reporevlogstore !)
-  linking [           <=>                                 ] 3\r (no-eol) (esc) (reporevlogstore !)
-  linking [            <=>                                ] 4\r (no-eol) (esc) (reporevlogstore !)
-  linking [             <=>                               ] 5\r (no-eol) (esc) (reporevlogstore !)
-  linking [              <=>                              ] 6\r (no-eol) (esc) (reporevlogstore !)
-  linking [           <=>                                 ] 1\r (no-eol) (esc) (reposimplestore !)
-  linking [            <=>                                ] 2\r (no-eol) (esc) (reposimplestore !)
-  linking [             <=>                               ] 3\r (no-eol) (esc) (reposimplestore !)
-  linking [              <=>                              ] 4\r (no-eol) (esc) (reposimplestore !)
-  linking [               <=>                             ] 5\r (no-eol) (esc) (reposimplestore !)
-  linking [                <=>                            ] 6\r (no-eol) (esc) (reposimplestore !)
+  linking [======>                                      ] 1/6\r (no-eol) (esc)
+  linking [==============>                              ] 2/6\r (no-eol) (esc)
+  linking [=====================>                       ] 3/6\r (no-eol) (esc)
+  linking [=============================>               ] 4/6\r (no-eol) (esc)
+  linking [====================================>        ] 5/6\r (no-eol) (esc)
+  linking [============================================>] 6/6\r (no-eol) (esc)
   updating [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   updating to branch default
   cloning subrepo sub1 from $TESTTMP/sub1
   cloning subrepo sub1/sub2 from $TESTTMP/sub2
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Largefiles is NOT enabled in the clone if the source repo doesn't require it
   $ grep largefiles cloned/.hg/hgrc
   [1]
 
 Checking cloned repo ids
 
   $ printf "cloned " ; hg id -R cloned
   cloned 7f491f53a367 tip
   $ printf "cloned/sub1 " ; hg id -R cloned/sub1
   cloned/sub1 fc3b4ce2696f tip
   $ printf "cloned/sub1/sub2 " ; hg id -R cloned/sub1/sub2
   cloned/sub1/sub2 c57a0840e3ba tip
 
 debugsub output for main and sub1
 
   $ hg debugsub -R cloned
   path sub1
    source   ../sub1
    revision fc3b4ce2696f7741438c79207583768f2ce6b0dd
   $ hg debugsub -R cloned/sub1
   path sub2
    source   ../sub2
    revision c57a0840e3badd667ef3c3ef65471609acb2ba3c
 
 Modifying deeply nested 'sub2'
 
   $ echo modified > cloned/sub1/sub2/sub2
   $ hg commit --subrepos -m "deep nested modif should trigger a commit" -R cloned
   committing subrepository sub1
   committing subrepository sub1/sub2
 
 Checking modified node ids
 
   $ printf "cloned " ; hg id -R cloned
   cloned ffe6649062fe tip
   $ printf "cloned/sub1 " ; hg id -R cloned/sub1
   cloned/sub1 2ecb03bf44a9 tip
   $ printf "cloned/sub1/sub2 " ; hg id -R cloned/sub1/sub2
   cloned/sub1/sub2 53dd3430bcaf tip
 
 debugsub output for main and sub1
 
   $ hg debugsub -R cloned
   path sub1
    source   ../sub1
    revision 2ecb03bf44a94e749e8669481dd9069526ce7cb9
   $ hg debugsub -R cloned/sub1
   path sub2
    source   ../sub2
    revision 53dd3430bcaf5ab4a7c48262bcad6d441f510487
 
 Check that deep archiving works
 
   $ cd cloned
   $ echo 'test' > sub1/sub2/test.txt
   $ hg --config extensions.largefiles=! add sub1/sub2/test.txt
   $ mkdir sub1/sub2/folder
   $ echo 'subfolder' > sub1/sub2/folder/test.txt
   $ hg ci -ASm "add test.txt"
   adding sub1/sub2/folder/test.txt
   committing subrepository sub1
   committing subrepository sub1/sub2
 
   $ rm -r main
   $ hg archive -S -qr 'wdir()' ../wdir
   $ cat ../wdir/.hg_archival.txt
   repo: 7f491f53a367861f47ee64a80eb997d1f341b77a
   node: 9bb10eebee29dc0f1201dcf5977b811a540255fd+
   branch: default
   latesttag: null
   latesttagdistance: 4
   changessincelatesttag: 4
   $ hg update -Cq .
 
 A deleted subrepo file is flagged as dirty, like the top level repo
 
   $ rm -r ../wdir sub1/sub2/folder/test.txt
   $ hg archive -S -qr 'wdir()' ../wdir
   $ cat ../wdir/.hg_archival.txt
   repo: 7f491f53a367861f47ee64a80eb997d1f341b77a
   node: 9bb10eebee29dc0f1201dcf5977b811a540255fd+
   branch: default
   latesttag: null
   latesttagdistance: 4
   changessincelatesttag: 4
   $ hg update -Cq .
   $ rm -r ../wdir
 
   $ hg archive -S -qr 'wdir()' ../wdir \
   >            --config 'experimental.archivemetatemplate=archived {node|short}\n'
   $ cat ../wdir/.hg_archival.txt
   archived ffffffffffff
   $ rm -r ../wdir
 
 .. but first take a detour through some deep removal testing
 
   $ hg remove -S -I 're:.*.txt' .
   \r (no-eol) (esc)
   searching [==========================================>] 1/1\r (no-eol) (esc)
   searching [==========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   deleting [=====================>                      ] 1/2\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   deleting [===========================================>] 2/2\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   removing sub1/sub2/folder/test.txt
   removing sub1/sub2/test.txt
   $ hg status -S
   R sub1/sub2/folder/test.txt
   R sub1/sub2/test.txt
   $ hg update -Cq
   $ hg remove -I 're:.*.txt' sub1
   \r (no-eol) (esc)
   searching [==========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   deleting [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ hg status -S
   $ hg remove sub1/sub2/folder/test.txt
   \r (no-eol) (esc)
   searching [==========================================>] 1/1\r (no-eol) (esc)
   searching [==========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   deleting [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   deleting [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   deleting [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ hg remove sub1/.hgsubstate
   \r (no-eol) (esc)
   searching [==========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   deleting [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   deleting [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ mv sub1/.hgsub sub1/x.hgsub
   $ hg status -S
   warning: subrepo spec file 'sub1/.hgsub' not found
   R sub1/.hgsubstate
   R sub1/sub2/folder/test.txt
   ! sub1/.hgsub
   ? sub1/x.hgsub
   $ hg status -R sub1
   warning: subrepo spec file 'sub1/.hgsub' not found
   R .hgsubstate
   ! .hgsub
   ? x.hgsub
   $ mv sub1/x.hgsub sub1/.hgsub
   $ hg update -Cq
   $ touch sub1/foo
   $ hg forget sub1/sub2/folder/test.txt
   $ rm sub1/sub2/test.txt
 
 Test relative path printing + subrepos
   $ mkdir -p foo/bar
   $ cd foo
   $ touch bar/abc
   $ hg addremove -S ..
   \r (no-eol) (esc)
   searching for exact renames [========================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   adding ../sub1/sub2/folder/test.txt
   removing ../sub1/sub2/test.txt
   adding ../sub1/foo
   adding bar/abc
   $ cd ..
   $ hg status -S
   A foo/bar/abc
   A sub1/foo
   R sub1/sub2/test.txt
 
 Archive wdir() with subrepos
   $ hg rm main
   \r (no-eol) (esc)
   deleting [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ hg archive -S -r 'wdir()' ../wdir
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1) [                                    ] 0/4\r (no-eol) (esc)
   archiving (sub1) [========>                           ] 1/4\r (no-eol) (esc)
   archiving (sub1) [=================>                  ] 2/4\r (no-eol) (esc)
   archiving (sub1) [==========================>         ] 3/4\r (no-eol) (esc)
   archiving (sub1) [===================================>] 4/4\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [                               ] 0/2\r (no-eol) (esc)
   archiving (sub1/sub2) [==============>                ] 1/2\r (no-eol) (esc)
   archiving (sub1/sub2) [==============================>] 2/2\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ diff -r . ../wdir | egrep -v '\.hg$|^Common subdirectories:'
   Only in ../wdir: .hg_archival.txt
 
   $ find ../wdir -type f | sort
   ../wdir/.hg_archival.txt
   ../wdir/.hgsub
   ../wdir/.hgsubstate
   ../wdir/foo/bar/abc
   ../wdir/sub1/.hgsub
   ../wdir/sub1/.hgsubstate
   ../wdir/sub1/foo
   ../wdir/sub1/sub1
   ../wdir/sub1/sub2/folder/test.txt
   ../wdir/sub1/sub2/sub2
 
   $ cat ../wdir/.hg_archival.txt
   repo: 7f491f53a367861f47ee64a80eb997d1f341b77a
   node: 9bb10eebee29dc0f1201dcf5977b811a540255fd+
   branch: default
   latesttag: null
   latesttagdistance: 4
   changessincelatesttag: 4
 
 Attempting to archive 'wdir()' with a missing file is handled gracefully
   $ rm sub1/sub1
   $ rm -r ../wdir
   $ hg archive -v -S -r 'wdir()' ../wdir
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1) [                                    ] 0/3\r (no-eol) (esc)
   archiving (sub1) [===========>                        ] 1/3\r (no-eol) (esc)
   archiving (sub1) [=======================>            ] 2/3\r (no-eol) (esc)
   archiving (sub1) [===================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [                               ] 0/2\r (no-eol) (esc)
   archiving (sub1/sub2) [==============>                ] 1/2\r (no-eol) (esc)
   archiving (sub1/sub2) [==============================>] 2/2\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ find ../wdir -type f | sort
   ../wdir/.hg_archival.txt
   ../wdir/.hgsub
   ../wdir/.hgsubstate
   ../wdir/foo/bar/abc
   ../wdir/sub1/.hgsub
   ../wdir/sub1/.hgsubstate
   ../wdir/sub1/foo
   ../wdir/sub1/sub2/folder/test.txt
   ../wdir/sub1/sub2/sub2
 
 Continue relative path printing + subrepos
   $ hg update -Cq
   $ rm -r ../wdir
   $ hg archive -S -r 'wdir()' ../wdir
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1) [                                    ] 0/3\r (no-eol) (esc)
   archiving (sub1) [===========>                        ] 1/3\r (no-eol) (esc)
   archiving (sub1) [=======================>            ] 2/3\r (no-eol) (esc)
   archiving (sub1) [===================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [                               ] 0/3\r (no-eol) (esc)
   archiving (sub1/sub2) [=========>                     ] 1/3\r (no-eol) (esc)
   archiving (sub1/sub2) [===================>           ] 2/3\r (no-eol) (esc)
   archiving (sub1/sub2) [==============================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ cat ../wdir/.hg_archival.txt
   repo: 7f491f53a367861f47ee64a80eb997d1f341b77a
   node: 9bb10eebee29dc0f1201dcf5977b811a540255fd
   branch: default
   latesttag: null
   latesttagdistance: 4
   changessincelatesttag: 4
 
   $ touch sub1/sub2/folder/bar
   $ hg addremove sub1/sub2
   adding sub1/sub2/folder/bar
   $ hg status -S
   A sub1/sub2/folder/bar
   ? foo/bar/abc
   ? sub1/foo
   $ hg update -Cq
   $ hg addremove sub1
   adding sub1/sub2/folder/bar
   adding sub1/foo
   $ hg update -Cq
   $ rm sub1/sub2/folder/test.txt
   $ rm sub1/sub2/test.txt
   $ hg ci -ASm "remove test.txt"
   adding sub1/sub2/folder/bar
   removing sub1/sub2/folder/test.txt
   removing sub1/sub2/test.txt
   adding sub1/foo
   adding foo/bar/abc
   committing subrepository sub1
   committing subrepository sub1/sub2
 
   $ hg forget sub1/sub2/sub2
   $ echo x > sub1/sub2/x.txt
   $ hg add sub1/sub2/x.txt
 
 Files sees uncommitted adds and removes in subrepos
   $ hg files -S
   .hgsub
   .hgsubstate
   foo/bar/abc
   main
   sub1/.hgsub
   sub1/.hgsubstate
   sub1/foo
   sub1/sub1
   sub1/sub2/folder/bar
   sub1/sub2/x.txt
 
   $ hg files -S "set:eol('dos') or eol('unix') or size('<= 0')"
   .hgsub
   .hgsubstate
   foo/bar/abc
   main
   sub1/.hgsub
   sub1/.hgsubstate
   sub1/foo
   sub1/sub1
   sub1/sub2/folder/bar
   sub1/sub2/x.txt
 
   $ hg files -r '.^' -S "set:eol('dos') or eol('unix')"
   .hgsub
   .hgsubstate
   main
   sub1/.hgsub
   sub1/.hgsubstate
   sub1/sub1
   sub1/sub2/folder/test.txt
   sub1/sub2/sub2
   sub1/sub2/test.txt
 
   $ hg files sub1
   sub1/.hgsub
   sub1/.hgsubstate
   sub1/foo
   sub1/sub1
   sub1/sub2/folder/bar
   sub1/sub2/x.txt
 
   $ hg files sub1/sub2
   sub1/sub2/folder/bar
   sub1/sub2/x.txt
 
   $ hg files
   .hgsub
   .hgsubstate
   foo/bar/abc
   main
 
   $ hg files -S -r '.^' sub1/sub2/folder
   sub1/sub2/folder/test.txt
 
   $ hg files -S -r '.^' sub1/sub2/missing
   sub1/sub2/missing: no such file in rev 78026e779ea6
   [1]
 
   $ hg files -r '.^' sub1/
   sub1/.hgsub
   sub1/.hgsubstate
   sub1/sub1
   sub1/sub2/folder/test.txt
   sub1/sub2/sub2
   sub1/sub2/test.txt
 
   $ hg files -r '.^' sub1/sub2
   sub1/sub2/folder/test.txt
   sub1/sub2/sub2
   sub1/sub2/test.txt
 
   $ hg rollback -q
   $ hg up -Cq
 
   $ hg --config extensions.largefiles=! archive -S ../archive_all
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1) [                                    ] 0/3\r (no-eol) (esc)
   archiving (sub1) [===========>                        ] 1/3\r (no-eol) (esc)
   archiving (sub1) [=======================>            ] 2/3\r (no-eol) (esc)
   archiving (sub1) [===================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [                               ] 0/3\r (no-eol) (esc)
   archiving (sub1/sub2) [=========>                     ] 1/3\r (no-eol) (esc)
   archiving (sub1/sub2) [===================>           ] 2/3\r (no-eol) (esc)
   archiving (sub1/sub2) [==============================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ find ../archive_all | sort
   ../archive_all
   ../archive_all/.hg_archival.txt
   ../archive_all/.hgsub
   ../archive_all/.hgsubstate
   ../archive_all/main
   ../archive_all/sub1
   ../archive_all/sub1/.hgsub
   ../archive_all/sub1/.hgsubstate
   ../archive_all/sub1/sub1
   ../archive_all/sub1/sub2
   ../archive_all/sub1/sub2/folder
   ../archive_all/sub1/sub2/folder/test.txt
   ../archive_all/sub1/sub2/sub2
   ../archive_all/sub1/sub2/test.txt
 
 Check that archive -X works in deep subrepos
 
   $ hg --config extensions.largefiles=! archive -S -X '**test*' ../archive_exclude
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1) [                                    ] 0/3\r (no-eol) (esc)
   archiving (sub1) [===========>                        ] 1/3\r (no-eol) (esc)
   archiving (sub1) [=======================>            ] 2/3\r (no-eol) (esc)
   archiving (sub1) [===================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [                               ] 0/1\r (no-eol) (esc)
   archiving (sub1/sub2) [==============================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ find ../archive_exclude | sort
   ../archive_exclude
   ../archive_exclude/.hg_archival.txt
   ../archive_exclude/.hgsub
   ../archive_exclude/.hgsubstate
   ../archive_exclude/main
   ../archive_exclude/sub1
   ../archive_exclude/sub1/.hgsub
   ../archive_exclude/sub1/.hgsubstate
   ../archive_exclude/sub1/sub1
   ../archive_exclude/sub1/sub2
   ../archive_exclude/sub1/sub2/sub2
 
   $ hg --config extensions.largefiles=! archive -S -I '**test*' ../archive_include
   \r (no-eol) (esc)
   archiving (sub1) [ <=>                                  ] 0\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [                               ] 0/2\r (no-eol) (esc)
   archiving (sub1/sub2) [==============>                ] 1/2\r (no-eol) (esc)
   archiving (sub1/sub2) [==============================>] 2/2\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ find ../archive_include | sort
   ../archive_include
   ../archive_include/sub1
   ../archive_include/sub1/sub2
   ../archive_include/sub1/sub2/folder
   ../archive_include/sub1/sub2/folder/test.txt
   ../archive_include/sub1/sub2/test.txt
 
 Check that deep archive works with largefiles (which overrides hgsubrepo impl)
 This also tests the repo.ui regression in 43fb170a23bd, and that lf subrepo
 subrepos are archived properly.
 Note that add --large through a subrepo currently adds the file as a normal file
 
   $ echo "large" > sub1/sub2/large.bin
   $ hg --config extensions.largefiles= add --large -R sub1/sub2 sub1/sub2/large.bin
   $ echo "large" > large.bin
   $ hg --config extensions.largefiles= add --large large.bin
   $ hg --config extensions.largefiles= ci -S -m "add large files"
   committing subrepository sub1
   committing subrepository sub1/sub2
 
   $ hg --config extensions.largefiles= archive -S ../archive_lf
   $ find ../archive_lf | sort
   ../archive_lf
   ../archive_lf/.hg_archival.txt
   ../archive_lf/.hgsub
   ../archive_lf/.hgsubstate
   ../archive_lf/large.bin
   ../archive_lf/main
   ../archive_lf/sub1
   ../archive_lf/sub1/.hgsub
   ../archive_lf/sub1/.hgsubstate
   ../archive_lf/sub1/sub1
   ../archive_lf/sub1/sub2
   ../archive_lf/sub1/sub2/folder
   ../archive_lf/sub1/sub2/folder/test.txt
   ../archive_lf/sub1/sub2/large.bin
   ../archive_lf/sub1/sub2/sub2
   ../archive_lf/sub1/sub2/test.txt
   $ rm -rf ../archive_lf
 
 Exclude large files from main and sub-sub repo
 
   $ hg --config extensions.largefiles= archive -S -X '**.bin' ../archive_lf
   $ find ../archive_lf | sort
   ../archive_lf
   ../archive_lf/.hg_archival.txt
   ../archive_lf/.hgsub
   ../archive_lf/.hgsubstate
   ../archive_lf/main
   ../archive_lf/sub1
   ../archive_lf/sub1/.hgsub
   ../archive_lf/sub1/.hgsubstate
   ../archive_lf/sub1/sub1
   ../archive_lf/sub1/sub2
   ../archive_lf/sub1/sub2/folder
   ../archive_lf/sub1/sub2/folder/test.txt
   ../archive_lf/sub1/sub2/sub2
   ../archive_lf/sub1/sub2/test.txt
   $ rm -rf ../archive_lf
 
 Exclude normal files from main and sub-sub repo
 
   $ hg --config extensions.largefiles= archive -S -X '**.txt' -p '.' ../archive_lf.tgz
   $ tar -tzf ../archive_lf.tgz | sort
   .hgsub
   .hgsubstate
   large.bin
   main
   sub1/.hgsub
   sub1/.hgsubstate
   sub1/sub1
   sub1/sub2/large.bin
   sub1/sub2/sub2
 
 Include normal files from within a largefiles subrepo
 
   $ hg --config extensions.largefiles= archive -S -I '**.txt' ../archive_lf
   $ find ../archive_lf | sort
   ../archive_lf
   ../archive_lf/.hg_archival.txt
   ../archive_lf/sub1
   ../archive_lf/sub1/sub2
   ../archive_lf/sub1/sub2/folder
   ../archive_lf/sub1/sub2/folder/test.txt
   ../archive_lf/sub1/sub2/test.txt
   $ rm -rf ../archive_lf
 
 Include large files from within a largefiles subrepo
 
   $ hg --config extensions.largefiles= archive -S -I '**.bin' ../archive_lf
   $ find ../archive_lf | sort
   ../archive_lf
   ../archive_lf/large.bin
   ../archive_lf/sub1
   ../archive_lf/sub1/sub2
   ../archive_lf/sub1/sub2/large.bin
   $ rm -rf ../archive_lf
 
 Find an exact largefile match in a largefiles subrepo
 
   $ hg --config extensions.largefiles= archive -S -I 'sub1/sub2/large.bin' ../archive_lf
   $ find ../archive_lf | sort
   ../archive_lf
   ../archive_lf/sub1
   ../archive_lf/sub1/sub2
   ../archive_lf/sub1/sub2/large.bin
   $ rm -rf ../archive_lf
 
 The local repo enables largefiles if a largefiles repo is cloned
 
   $ hg showconfig extensions
   extensions.largefiles=
 
   $ hg --config extensions.largefiles= clone -qU . ../lfclone
   $ grep largefiles ../lfclone/.hg/requires
   largefiles
 
 Find an exact match to a standin (should archive nothing)
   $ hg --config extensions.largefiles= archive -S -I 'sub/sub2/.hglf/large.bin' ../archive_lf
   $ find ../archive_lf 2> /dev/null | sort
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > largefiles=
   > [largefiles]
   > patterns=glob:**.dat
   > EOF
 
 Test forget through a deep subrepo with the largefiles extension, both a
 largefile and a normal file.  Then a largefile that hasn't been committed yet.
   $ touch sub1/sub2/untracked.txt
   $ touch sub1/sub2/large.dat
   $ hg forget sub1/sub2/large.bin sub1/sub2/test.txt sub1/sub2/untracked.txt
   not removing sub1/sub2/untracked.txt: file is already untracked
   [1]
   $ hg add --large --dry-run -v sub1/sub2/untracked.txt
   adding sub1/sub2/untracked.txt as a largefile
   $ hg add --large -v sub1/sub2/untracked.txt
   adding sub1/sub2/untracked.txt as a largefile
   $ hg add --normal -v sub1/sub2/large.dat
   adding sub1/sub2/large.dat
   $ hg forget -v sub1/sub2/untracked.txt
   removing sub1/sub2/untracked.txt
   $ hg status -S
   A sub1/sub2/large.dat
   R sub1/sub2/large.bin
   R sub1/sub2/test.txt
   ? foo/bar/abc
   ? sub1/sub2/untracked.txt
   ? sub1/sub2/x.txt
   $ hg add sub1/sub2
 
   $ hg archive -S -r 'wdir()' ../wdir2
   $ diff -r . ../wdir2 | egrep -v '\.hg$|^Common subdirectories:'
   Only in ../wdir2: .hg_archival.txt
   Only in .: .hglf
   Only in .: foo
   Only in ./sub1/sub2: large.bin
   Only in ./sub1/sub2: test.txt
   Only in ./sub1/sub2: untracked.txt
   Only in ./sub1/sub2: x.txt
   $ find ../wdir2 -type f | sort
   ../wdir2/.hg_archival.txt
   ../wdir2/.hgsub
   ../wdir2/.hgsubstate
   ../wdir2/large.bin
   ../wdir2/main
   ../wdir2/sub1/.hgsub
   ../wdir2/sub1/.hgsubstate
   ../wdir2/sub1/sub1
   ../wdir2/sub1/sub2/folder/test.txt
   ../wdir2/sub1/sub2/large.dat
   ../wdir2/sub1/sub2/sub2
   $ hg status -S -mac -n | sort
   .hgsub
   .hgsubstate
   large.bin
   main
   sub1/.hgsub
   sub1/.hgsubstate
   sub1/sub1
   sub1/sub2/folder/test.txt
   sub1/sub2/large.dat
   sub1/sub2/sub2
 
   $ hg ci -Sqm 'forget testing'
 
 Test 'wdir()' modified file archiving with largefiles
   $ echo 'mod' > main
   $ echo 'mod' > large.bin
   $ echo 'mod' > sub1/sub2/large.dat
   $ hg archive -S -r 'wdir()' ../wdir3
   $ diff -r . ../wdir3 | egrep -v '\.hg$|^Common subdirectories'
   Only in ../wdir3: .hg_archival.txt
   Only in .: .hglf
   Only in .: foo
   Only in ./sub1/sub2: large.bin
   Only in ./sub1/sub2: test.txt
   Only in ./sub1/sub2: untracked.txt
   Only in ./sub1/sub2: x.txt
   $ find ../wdir3 -type f | sort
   ../wdir3/.hg_archival.txt
   ../wdir3/.hgsub
   ../wdir3/.hgsubstate
   ../wdir3/large.bin
   ../wdir3/main
   ../wdir3/sub1/.hgsub
   ../wdir3/sub1/.hgsubstate
   ../wdir3/sub1/sub1
   ../wdir3/sub1/sub2/folder/test.txt
   ../wdir3/sub1/sub2/large.dat
   ../wdir3/sub1/sub2/sub2
   $ hg up -Cq
 
 Test issue4330: commit a directory where only normal files have changed
   $ touch foo/bar/large.dat
   $ hg add --large foo/bar/large.dat
   $ hg ci -m 'add foo/bar/large.dat'
   $ touch a.txt
   $ touch a.dat
   $ hg add -v foo/bar/abc a.txt a.dat
   adding a.dat as a largefile
   adding a.txt
   adding foo/bar/abc
   $ hg ci -m 'dir commit with only normal file deltas' foo/bar
   $ hg status
   A a.dat
   A a.txt
 
 Test a directory commit with a changed largefile and a changed normal file
   $ echo changed > foo/bar/large.dat
   $ echo changed > foo/bar/abc
   $ hg ci -m 'dir commit with normal and lf file deltas' foo
   $ hg status
   A a.dat
   A a.txt
 
   $ hg ci -m "add a.*"
   $ hg mv a.dat b.dat
   $ hg mv foo/bar/abc foo/bar/def
   $ hg status -C
   A b.dat
     a.dat
   A foo/bar/def
     foo/bar/abc
   R a.dat
   R foo/bar/abc
 
   $ hg ci -m "move large and normal"
   $ hg status -C --rev '.^' --rev .
   A b.dat
     a.dat
   A foo/bar/def
     foo/bar/abc
   R a.dat
   R foo/bar/abc
 
 
   $ echo foo > main
   $ hg ci -m "mod parent only"
   $ hg init sub3
   $ echo "sub3 = sub3" >> .hgsub
   $ echo xyz > sub3/a.txt
   $ hg add sub3/a.txt
   $ hg ci -Sm "add sub3"
   committing subrepository sub3
   $ cat .hgsub | grep -v sub3 > .hgsub1
   $ mv .hgsub1 .hgsub
   $ hg ci -m "remove sub3"
 
   $ hg log -r "subrepo()" --style compact
   0   7f491f53a367   1970-01-01 00:00 +0000   test
     main import
   
   1   ffe6649062fe   1970-01-01 00:00 +0000   test
     deep nested modif should trigger a commit
   
   2   9bb10eebee29   1970-01-01 00:00 +0000   test
     add test.txt
   
   3   7c64f035294f   1970-01-01 00:00 +0000   test
     add large files
   
   4   f734a59e2e35   1970-01-01 00:00 +0000   test
     forget testing
   
   11   9685a22af5db   1970-01-01 00:00 +0000   test
     add sub3
   
   12[tip]   2e0485b475b9   1970-01-01 00:00 +0000   test
     remove sub3
   
   $ hg log -r "subrepo('sub3')" --style compact
   11   9685a22af5db   1970-01-01 00:00 +0000   test
     add sub3
   
   12[tip]   2e0485b475b9   1970-01-01 00:00 +0000   test
     remove sub3
   
   $ hg log -r "subrepo('bogus')" --style compact
 
 
 Test .hgsubstate in the R state
 
   $ hg rm .hgsub .hgsubstate
   \r (no-eol) (esc)
   deleting [=====================>                      ] 1/2\r (no-eol) (esc)
   deleting [===========================================>] 2/2\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ hg ci -m 'trash subrepo tracking'
 
   $ hg log -r "subrepo('re:sub\d+')" --style compact
   0   7f491f53a367   1970-01-01 00:00 +0000   test
     main import
   
   1   ffe6649062fe   1970-01-01 00:00 +0000   test
     deep nested modif should trigger a commit
   
   2   9bb10eebee29   1970-01-01 00:00 +0000   test
     add test.txt
   
   3   7c64f035294f   1970-01-01 00:00 +0000   test
     add large files
   
   4   f734a59e2e35   1970-01-01 00:00 +0000   test
     forget testing
   
   11   9685a22af5db   1970-01-01 00:00 +0000   test
     add sub3
   
   12   2e0485b475b9   1970-01-01 00:00 +0000   test
     remove sub3
   
   13[tip]   a68b2c361653   1970-01-01 00:00 +0000   test
     trash subrepo tracking
   
 
 Restore the trashed subrepo tracking
 
   $ hg rollback -q
   $ hg update -Cq .
 
 Interaction with extdiff, largefiles and subrepos
 
   $ hg --config extensions.extdiff= pdiff -S
 
   $ hg --config extensions.extdiff= pdiff -r '.^' -S
   \r (no-eol) (esc)
   archiving [                                           ] 0/2\r (no-eol) (esc)
   archiving [====================>                      ] 1/2\r (no-eol) (esc)
   archiving [==========================================>] 2/2\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1) [ <=>                                  ] 0\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [ <=>                             ] 0\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub3) [ <=>                                  ] 0\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving [                                           ] 0/2\r (no-eol) (esc)
   archiving [====================>                      ] 1/2\r (no-eol) (esc)
   archiving [==========================================>] 2/2\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1) [ <=>                                  ] 0\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [ <=>                             ] 0\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   diff -Nru cloned.*/.hgsub cloned/.hgsub (glob)
   --- cloned.*/.hgsub	* (glob)
   +++ cloned/.hgsub	* (glob)
   @@ -1,2 +1* @@ (glob)
    sub1 = ../sub1
   -sub3 = sub3
   diff -Nru cloned.*/.hgsubstate cloned/.hgsubstate (glob)
   --- cloned.*/.hgsubstate	* (glob)
   +++ cloned/.hgsubstate	* (glob)
   @@ -1,2 +1* @@ (glob)
    7a36fa02b66e61f27f3d4a822809f159479b8ab2 sub1
   -b1a26de6f2a045a9f079323693614ee322f1ff7e sub3
   [1]
 
   $ hg --config extensions.extdiff= pdiff -r 0 -r '.^' -S
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1) [                                    ] 0/1\r (no-eol) (esc)
   archiving (sub1) [===================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [                               ] 0/1\r (no-eol) (esc)
   archiving (sub1/sub2) [==============================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving [                                           ] 0/8\r (no-eol) (esc)
   archiving [====>                                      ] 1/8\r (no-eol) (esc)
   archiving [=========>                                 ] 2/8\r (no-eol) (esc)
   archiving [===============>                           ] 3/8\r (no-eol) (esc)
   archiving [====================>                      ] 4/8\r (no-eol) (esc)
   archiving [=========================>                 ] 5/8\r (no-eol) (esc)
   archiving [===============================>           ] 6/8\r (no-eol) (esc)
   archiving [====================================>      ] 7/8\r (no-eol) (esc)
   archiving [==========================================>] 8/8\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1) [                                    ] 0/1\r (no-eol) (esc)
   archiving (sub1) [===================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [                               ] 0/3\r (no-eol) (esc)
   archiving (sub1/sub2) [=========>                     ] 1/3\r (no-eol) (esc)
   archiving (sub1/sub2) [===================>           ] 2/3\r (no-eol) (esc)
   archiving (sub1/sub2) [==============================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub3) [                                    ] 0/1\r (no-eol) (esc)
   archiving (sub3) [===================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   diff -Nru cloned.*/.hglf/b.dat cloned.*/.hglf/b.dat (glob)
   --- cloned.*/.hglf/b.dat	* (glob)
   +++ cloned.*/.hglf/b.dat	* (glob)
   @@ -*,0 +1* @@ (glob)
   +da39a3ee5e6b4b0d3255bfef95601890afd80709
   diff -Nru cloned.*/.hglf/foo/bar/large.dat cloned.*/.hglf/foo/bar/large.dat (glob)
   --- cloned.*/.hglf/foo/bar/large.dat	* (glob)
   +++ cloned.*/.hglf/foo/bar/large.dat	* (glob)
   @@ -*,0 +1* @@ (glob)
   +2f6933b5ee0f5fdd823d9717d8729f3c2523811b
   diff -Nru cloned.*/.hglf/large.bin cloned.*/.hglf/large.bin (glob)
   --- cloned.*/.hglf/large.bin	* (glob)
   +++ cloned.*/.hglf/large.bin	* (glob)
   @@ -*,0 +1* @@ (glob)
   +7f7097b041ccf68cc5561e9600da4655d21c6d18
   diff -Nru cloned.*/.hgsub cloned.*/.hgsub (glob)
   --- cloned.*/.hgsub	* (glob)
   +++ cloned.*/.hgsub	* (glob)
   @@ -1* +1,2 @@ (glob)
    sub1 = ../sub1
   +sub3 = sub3
   diff -Nru cloned.*/.hgsubstate cloned.*/.hgsubstate (glob)
   --- cloned.*/.hgsubstate	* (glob)
   +++ cloned.*/.hgsubstate	* (glob)
   @@ -1* +1,2 @@ (glob)
   -fc3b4ce2696f7741438c79207583768f2ce6b0dd sub1
   +7a36fa02b66e61f27f3d4a822809f159479b8ab2 sub1
   +b1a26de6f2a045a9f079323693614ee322f1ff7e sub3
   diff -Nru cloned.*/foo/bar/def cloned.*/foo/bar/def (glob)
   --- cloned.*/foo/bar/def	* (glob)
   +++ cloned.*/foo/bar/def	* (glob)
   @@ -*,0 +1* @@ (glob)
   +changed
   diff -Nru cloned.*/main cloned.*/main (glob)
   --- cloned.*/main	* (glob)
   +++ cloned.*/main	* (glob)
   @@ -1* +1* @@ (glob)
   -main
   +foo
   diff -Nru cloned.*/sub1/.hgsubstate cloned.*/sub1/.hgsubstate (glob)
   --- cloned.*/sub1/.hgsubstate	* (glob)
   +++ cloned.*/sub1/.hgsubstate	* (glob)
   @@ -1* +1* @@ (glob)
   -c57a0840e3badd667ef3c3ef65471609acb2ba3c sub2
   +c77908c81ccea3794a896c79e98b0e004aee2e9e sub2
   diff -Nru cloned.*/sub1/sub2/folder/test.txt cloned.*/sub1/sub2/folder/test.txt (glob)
   --- cloned.*/sub1/sub2/folder/test.txt	* (glob)
   +++ cloned.*/sub1/sub2/folder/test.txt	* (glob)
   @@ -*,0 +1* @@ (glob)
   +subfolder
   diff -Nru cloned.*/sub1/sub2/sub2 cloned.*/sub1/sub2/sub2 (glob)
   --- cloned.*/sub1/sub2/sub2	* (glob)
   +++ cloned.*/sub1/sub2/sub2	* (glob)
   @@ -1* +1* @@ (glob)
   -sub2
   +modified
   diff -Nru cloned.*/sub3/a.txt cloned.*/sub3/a.txt (glob)
   --- cloned.*/sub3/a.txt	* (glob)
   +++ cloned.*/sub3/a.txt	* (glob)
   @@ -*,0 +1* @@ (glob)
   +xyz
   [1]
 
   $ echo mod > sub1/sub2/sub2
   $ hg --config extensions.extdiff= pdiff -S
   \r (no-eol) (esc)
   archiving (sub1) [ <=>                                  ] 0\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [                               ] 0/1\r (no-eol) (esc)
   archiving (sub1/sub2) [==============================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   --- */cloned.*/sub1/sub2/sub2	* (glob)
   +++ */cloned/sub1/sub2/sub2	* (glob)
   @@ -1* +1* @@ (glob)
   -modified
   +mod
   [1]
 
   $ cd ..

tests/test-subrepo-recursion.t

@@ -1,715 +1,700 b''
 Create test repository:
 
   $ hg init repo
   $ cd repo
   $ echo x1 > x.txt
 
   $ hg init foo
   $ cd foo
   $ echo y1 > y.txt
 
   $ hg init bar
   $ cd bar
   $ echo z1 > z.txt
 
   $ cd ..
   $ echo 'bar = bar' > .hgsub
 
   $ cd ..
   $ echo 'foo = foo' > .hgsub
 
 Add files --- .hgsub files must go first to trigger subrepos:
 
   $ hg add -S .hgsub
   $ hg add -S foo/.hgsub
   $ hg add -S foo/bar
   adding foo/bar/z.txt
   $ hg add -S
   adding x.txt
   adding foo/y.txt
 
 Test recursive status without committing anything:
 
   $ hg status -S
   A .hgsub
   A foo/.hgsub
   A foo/bar/z.txt
   A foo/y.txt
   A x.txt
 
 Test recursive diff without committing anything:
 
   $ hg diff --nodates -S foo
   diff -r 000000000000 foo/.hgsub
   --- /dev/null
   +++ b/foo/.hgsub
   @@ -0,0 +1,1 @@
   +bar = bar
   diff -r 000000000000 foo/y.txt
   --- /dev/null
   +++ b/foo/y.txt
   @@ -0,0 +1,1 @@
   +y1
   diff -r 000000000000 foo/bar/z.txt
   --- /dev/null
   +++ b/foo/bar/z.txt
   @@ -0,0 +1,1 @@
   +z1
 
 Commits:
 
   $ hg commit -m fails
   abort: uncommitted changes in subrepository "foo"
   (use --subrepos for recursive commit)
   [255]
 
 The --subrepos flag overwrite the config setting:
 
   $ hg commit -m 0-0-0 --config ui.commitsubrepos=No --subrepos
   committing subrepository foo
   committing subrepository foo/bar
 
   $ cd foo
   $ echo y2 >> y.txt
   $ hg commit -m 0-1-0
 
   $ cd bar
   $ echo z2 >> z.txt
   $ hg commit -m 0-1-1
 
   $ cd ..
   $ hg commit -m 0-2-1
 
   $ cd ..
   $ hg commit -m 1-2-1
 
 Change working directory:
 
   $ echo y3 >> foo/y.txt
   $ echo z3 >> foo/bar/z.txt
   $ hg status -S
   M foo/bar/z.txt
   M foo/y.txt
   $ hg diff --nodates -S
   diff -r d254738c5f5e foo/y.txt
   --- a/foo/y.txt
   +++ b/foo/y.txt
   @@ -1,2 +1,3 @@
    y1
    y2
   +y3
   diff -r 9647f22de499 foo/bar/z.txt
   --- a/foo/bar/z.txt
   +++ b/foo/bar/z.txt
   @@ -1,2 +1,3 @@
    z1
    z2
   +z3
 
 Status call crossing repository boundaries:
 
   $ hg status -S foo/bar/z.txt
   M foo/bar/z.txt
   $ hg status -S -I 'foo/?.txt'
   M foo/y.txt
   $ hg status -S -I '**/?.txt'
   M foo/bar/z.txt
   M foo/y.txt
   $ hg diff --nodates -S -I '**/?.txt'
   diff -r d254738c5f5e foo/y.txt
   --- a/foo/y.txt
   +++ b/foo/y.txt
   @@ -1,2 +1,3 @@
    y1
    y2
   +y3
   diff -r 9647f22de499 foo/bar/z.txt
   --- a/foo/bar/z.txt
   +++ b/foo/bar/z.txt
   @@ -1,2 +1,3 @@
    z1
    z2
   +z3
 
 Status from within a subdirectory:
 
   $ mkdir dir
   $ cd dir
   $ echo a1 > a.txt
   $ hg status -S
   M foo/bar/z.txt
   M foo/y.txt
   ? dir/a.txt
   $ hg diff --nodates -S
   diff -r d254738c5f5e foo/y.txt
   --- a/foo/y.txt
   +++ b/foo/y.txt
   @@ -1,2 +1,3 @@
    y1
    y2
   +y3
   diff -r 9647f22de499 foo/bar/z.txt
   --- a/foo/bar/z.txt
   +++ b/foo/bar/z.txt
   @@ -1,2 +1,3 @@
    z1
    z2
   +z3
 
 Status with relative path:
 
   $ hg status -S ..
   M ../foo/bar/z.txt
   M ../foo/y.txt
   ? a.txt
 
 XXX: filtering lfilesrepo.status() in 3.3-rc causes these files to be listed as
 added instead of modified.
   $ hg status -S .. --config extensions.largefiles=
   M ../foo/bar/z.txt
   M ../foo/y.txt
   ? a.txt
 
   $ hg diff --nodates -S ..
   diff -r d254738c5f5e foo/y.txt
   --- a/foo/y.txt
   +++ b/foo/y.txt
   @@ -1,2 +1,3 @@
    y1
    y2
   +y3
   diff -r 9647f22de499 foo/bar/z.txt
   --- a/foo/bar/z.txt
   +++ b/foo/bar/z.txt
   @@ -1,2 +1,3 @@
    z1
    z2
   +z3
   $ cd ..
 
 Cleanup and final commit:
 
   $ rm -r dir
   $ hg commit --subrepos -m 2-3-2
   committing subrepository foo
   committing subrepository foo/bar
 
 Test explicit path commands within subrepos: add/forget
   $ echo z1 > foo/bar/z2.txt
   $ hg status -S
   ? foo/bar/z2.txt
   $ hg add foo/bar/z2.txt
   $ hg status -S
   A foo/bar/z2.txt
   $ hg forget foo/bar/z2.txt
   $ hg status -S
   ? foo/bar/z2.txt
   $ hg forget foo/bar/z2.txt
   not removing foo/bar/z2.txt: file is already untracked
   [1]
   $ hg status -S
   ? foo/bar/z2.txt
   $ rm foo/bar/z2.txt
 
 Log with the relationships between repo and its subrepo:
 
   $ hg log --template '{rev}:{node|short} {desc}\n'
   2:1326fa26d0c0 2-3-2
   1:4b3c9ff4f66b 1-2-1
   0:23376cbba0d8 0-0-0
 
   $ hg -R foo log --template '{rev}:{node|short} {desc}\n'
   3:65903cebad86 2-3-2
   2:d254738c5f5e 0-2-1
   1:8629ce7dcc39 0-1-0
   0:af048e97ade2 0-0-0
 
   $ hg -R foo/bar log --template '{rev}:{node|short} {desc}\n'
   2:31ecbdafd357 2-3-2
   1:9647f22de499 0-1-1
   0:4904098473f9 0-0-0
 
 Status between revisions:
 
   $ hg status -S
   $ hg status -S --rev 0:1
   M .hgsubstate
   M foo/.hgsubstate
   M foo/bar/z.txt
   M foo/y.txt
   $ hg diff --nodates -S -I '**/?.txt' --rev 0:1
   diff -r af048e97ade2 -r d254738c5f5e foo/y.txt
   --- a/foo/y.txt
   +++ b/foo/y.txt
   @@ -1,1 +1,2 @@
    y1
   +y2
   diff -r 4904098473f9 -r 9647f22de499 foo/bar/z.txt
   --- a/foo/bar/z.txt
   +++ b/foo/bar/z.txt
   @@ -1,1 +1,2 @@
    z1
   +z2
 
 #if serve
   $ cd ..
   $ hg serve -R repo --debug -S -p $HGPORT -d --pid-file=hg1.pid -E error.log -A access.log
   adding  = $TESTTMP/repo
   adding foo = $TESTTMP/repo/foo
   adding foo/bar = $TESTTMP/repo/foo/bar
   listening at http://*:$HGPORT/ (bound to *:$HGPORT) (glob) (?)
   adding  = $TESTTMP/repo (?)
   adding foo = $TESTTMP/repo/foo (?)
   adding foo/bar = $TESTTMP/repo/foo/bar (?)
   $ cat hg1.pid >> $DAEMON_PIDS
 
   $ hg clone http://localhost:$HGPORT clone  --config progress.disable=True
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 5 changes to 3 files
   new changesets 23376cbba0d8:1326fa26d0c0
   updating to branch default
   cloning subrepo foo from http://localhost:$HGPORT/foo
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 7 changes to 3 files
   new changesets af048e97ade2:65903cebad86
   cloning subrepo foo/bar from http://localhost:$HGPORT/foo/bar
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 1 files
   new changesets 4904098473f9:31ecbdafd357
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cat clone/foo/bar/z.txt
   z1
   z2
   z3
 
 Clone pooling from a remote URL will share the top level repo and the subrepos,
 even if they are referenced by remote URL.
 
   $ hg --config extensions.share= --config share.pool=$TESTTMP/pool \
   >    clone http://localhost:$HGPORT shared
   (sharing from new pooled repository 23376cbba0d87c15906bb3652584927c140907bf)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 5 changes to 3 files
   new changesets 23376cbba0d8:1326fa26d0c0
   searching for changes
   no changes found
   updating working directory
   cloning subrepo foo from http://localhost:$HGPORT/foo
   (sharing from new pooled repository af048e97ade2e236f754f05d07013e586af0f8bf)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 7 changes to 3 files
   new changesets af048e97ade2:65903cebad86
   searching for changes
   no changes found
   cloning subrepo foo/bar from http://localhost:$HGPORT/foo/bar
   (sharing from new pooled repository 4904098473f96c900fec436dad267edd4da59fad)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 1 files
   new changesets 4904098473f9:31ecbdafd357
   searching for changes
   no changes found
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cat access.log
   * "GET /?cmd=capabilities HTTP/1.1" 200 - (glob)
   * "GET /?cmd=batch HTTP/1.1" 200 - * (glob)
   * "GET /?cmd=getbundle HTTP/1.1" 200 - * (glob)
   * "GET /foo?cmd=capabilities HTTP/1.1" 200 - (glob)
   * "GET /foo?cmd=batch HTTP/1.1" 200 - * (glob)
   * "GET /foo?cmd=getbundle HTTP/1.1" 200 - * (glob)
   * "GET /foo/bar?cmd=capabilities HTTP/1.1" 200 - (glob)
   * "GET /foo/bar?cmd=batch HTTP/1.1" 200 - * (glob)
   * "GET /foo/bar?cmd=getbundle HTTP/1.1" 200 - * (glob)
   $LOCALIP - - [$LOGDATE$] "GET /?cmd=capabilities HTTP/1.1" 200 - (glob)
   $LOCALIP - - [$LOGDATE$] "GET /?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=0 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull (glob)
   $LOCALIP - - [$LOGDATE$] "GET /?cmd=capabilities HTTP/1.1" 200 - (glob)
   $LOCALIP - - [$LOGDATE$] "GET /?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=heads+%3Bknown+nodes%3D x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull (glob)
   $LOCALIP - - [$LOGDATE$] "GET /?cmd=getbundle HTTP/1.1" 200 - x-hgarg-1:bookmarks=1&$USUAL_BUNDLE_CAPS$&cg=1&common=0000000000000000000000000000000000000000&heads=1326fa26d0c00d2146c63b56bb6a45149d7325ac&listkeys=bookmarks&phases=1 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull (glob)
   $LOCALIP - - [$LOGDATE$] "GET /?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=heads+%3Bknown+nodes%3D1326fa26d0c00d2146c63b56bb6a45149d7325ac x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull (glob)
   $LOCALIP - - [$LOGDATE$] "GET /?cmd=getbundle HTTP/1.1" 200 - x-hgarg-1:bookmarks=1&$USUAL_BUNDLE_CAPS$&cg=0&common=1326fa26d0c00d2146c63b56bb6a45149d7325ac&heads=1326fa26d0c00d2146c63b56bb6a45149d7325ac&listkeys=bookmarks&phases=1 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo?cmd=capabilities HTTP/1.1" 200 - (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=0 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo?cmd=capabilities HTTP/1.1" 200 - (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=heads+%3Bknown+nodes%3D x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo?cmd=getbundle HTTP/1.1" 200 - x-hgarg-1:bookmarks=1&$USUAL_BUNDLE_CAPS$&cg=1&common=0000000000000000000000000000000000000000&heads=65903cebad86f1a84bd4f1134f62fa7dcb7a1c98&listkeys=bookmarks&phases=1 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=heads+%3Bknown+nodes%3D65903cebad86f1a84bd4f1134f62fa7dcb7a1c98 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo?cmd=getbundle HTTP/1.1" 200 - x-hgarg-1:bookmarks=1&$USUAL_BUNDLE_CAPS$&cg=0&common=65903cebad86f1a84bd4f1134f62fa7dcb7a1c98&heads=65903cebad86f1a84bd4f1134f62fa7dcb7a1c98&listkeys=bookmarks&phases=1 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo/bar?cmd=capabilities HTTP/1.1" 200 - (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo/bar?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=0 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo/bar?cmd=capabilities HTTP/1.1" 200 - (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo/bar?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=heads+%3Bknown+nodes%3D x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo/bar?cmd=getbundle HTTP/1.1" 200 - x-hgarg-1:bookmarks=1&$USUAL_BUNDLE_CAPS$&cg=1&common=0000000000000000000000000000000000000000&heads=31ecbdafd357f54b281c9bd1d681bb90de219e22&listkeys=bookmarks&phases=1 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo/bar?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=heads+%3Bknown+nodes%3D31ecbdafd357f54b281c9bd1d681bb90de219e22 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo/bar?cmd=getbundle HTTP/1.1" 200 - x-hgarg-1:bookmarks=1&$USUAL_BUNDLE_CAPS$&cg=0&common=31ecbdafd357f54b281c9bd1d681bb90de219e22&heads=31ecbdafd357f54b281c9bd1d681bb90de219e22&listkeys=bookmarks&phases=1 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ partial-pull (glob)
 
   $ killdaemons.py
   $ rm hg1.pid error.log access.log
   $ cd repo
 #endif
 
 Enable progress extension for archive tests:
 
   $ cp $HGRCPATH $HGRCPATH.no-progress
   $ cat >> $HGRCPATH <<EOF
   > [progress]
   > disable=False
   > assume-tty = 1
   > delay = 0
   > # set changedelay really large so we don't see nested topics
   > changedelay = 30000
   > format = topic bar number
   > refresh = 0
   > width = 60
   > EOF
 
 Test archiving to a directory tree (the doubled lines in the output
 only show up in the test output, not in real usage):
 
   $ hg archive --subrepos ../archive
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (foo) [                                     ] 0/3\r (no-eol) (esc)
   archiving (foo) [===========>                         ] 1/3\r (no-eol) (esc)
   archiving (foo) [=======================>             ] 2/3\r (no-eol) (esc)
   archiving (foo) [====================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (foo/bar) [                                 ] 0/1\r (no-eol) (esc)
   archiving (foo/bar) [================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ find ../archive | sort
   ../archive
   ../archive/.hg_archival.txt
   ../archive/.hgsub
   ../archive/.hgsubstate
   ../archive/foo
   ../archive/foo/.hgsub
   ../archive/foo/.hgsubstate
   ../archive/foo/bar
   ../archive/foo/bar/z.txt
   ../archive/foo/y.txt
   ../archive/x.txt
 
 Test archiving to zip file (unzip output is unstable):
 
   $ hg archive --subrepos --prefix '.' ../archive.zip
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (foo) [                                     ] 0/3\r (no-eol) (esc)
   archiving (foo) [===========>                         ] 1/3\r (no-eol) (esc)
   archiving (foo) [=======================>             ] 2/3\r (no-eol) (esc)
   archiving (foo) [====================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (foo/bar) [                                 ] 0/1\r (no-eol) (esc)
   archiving (foo/bar) [================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
 
 (unzip date formating is unstable, we do not care about it and glob it out)
 
   $ unzip -l ../archive.zip | grep -v -- ----- | egrep -v files$
   Archive:  ../archive.zip
     Length [ ]* Date [ ]* Time [ ]* Name (re)
         172  [0-9:\- ]*  .hg_archival.txt (re)
          10  [0-9:\- ]*  .hgsub (re)
          45  [0-9:\- ]*  .hgsubstate (re)
           3  [0-9:\- ]*  x.txt (re)
          10  [0-9:\- ]*  foo/.hgsub (re)
          45  [0-9:\- ]*  foo/.hgsubstate (re)
           9  [0-9:\- ]*  foo/y.txt (re)
           9  [0-9:\- ]*  foo/bar/z.txt (re)
 
 Test archiving a revision that references a subrepo that is not yet
 cloned:
 
 #if hardlink
   $ hg clone -U . ../empty
   \r (no-eol) (esc)
-  linking [ <=>                                           ] 1\r (no-eol) (esc)
-  linking [  <=>                                          ] 2\r (no-eol) (esc)
-  linking [   <=>                                         ] 3\r (no-eol) (esc)
-  linking [    <=>                                        ] 4\r (no-eol) (esc)
-  linking [     <=>                                       ] 5\r (no-eol) (esc)
-  linking [      <=>                                      ] 6\r (no-eol) (esc)
-  linking [       <=>                                     ] 7\r (no-eol) (esc)
-  linking [        <=>                                    ] 8\r (no-eol) (esc)
-  linking [         <=>                                   ] 9\r (no-eol) (esc) (reposimplestore !)
-  linking [          <=>                                 ] 10\r (no-eol) (esc) (reposimplestore !)
-  linking [           <=>                                ] 11\r (no-eol) (esc) (reposimplestore !)
-  linking [            <=>                               ] 12\r (no-eol) (esc) (reposimplestore !)
-  linking [             <=>                              ] 13\r (no-eol) (esc) (reposimplestore !)
+  linking [====>                                        ] 1/9\r (no-eol) (esc)
+  linking [=========>                                   ] 2/9\r (no-eol) (esc)
+  linking [==============>                              ] 3/9\r (no-eol) (esc)
+  linking [===================>                         ] 4/9\r (no-eol) (esc)
+  linking [========================>                    ] 5/9\r (no-eol) (esc)
+  linking [=============================>               ] 6/9\r (no-eol) (esc)
+  linking [==================================>          ] 7/9\r (no-eol) (esc)
+  linking [=======================================>     ] 8/9\r (no-eol) (esc)
+  linking [============================================>] 9/9\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
 #else
   $ hg clone -U . ../empty
   \r (no-eol) (esc)
   linking [ <=>                                           ] 1 (no-eol)
 #endif
 
   $ cd ../empty
 #if hardlink
   $ hg archive --subrepos -r tip --prefix './' ../archive.tar.gz
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
-  linking [ <=>                                           ] 1\r (no-eol) (esc)
-  linking [  <=>                                          ] 2\r (no-eol) (esc)
-  linking [   <=>                                         ] 3\r (no-eol) (esc)
-  linking [    <=>                                        ] 4\r (no-eol) (esc)
-  linking [     <=>                                       ] 5\r (no-eol) (esc)
-  linking [      <=>                                      ] 6\r (no-eol) (esc)
-  linking [       <=>                                     ] 7\r (no-eol) (esc)
-  linking [        <=>                                    ] 8\r (no-eol) (esc)
-  linking [         <=>                                   ] 9\r (no-eol) (esc) (reposimplestore !)
-  linking [          <=>                                 ] 10\r (no-eol) (esc) (reposimplestore !)
-  linking [           <=>                                ] 11\r (no-eol) (esc) (reposimplestore !)
-  linking [            <=>                               ] 12\r (no-eol) (esc) (reposimplestore !)
-  linking [             <=>                              ] 13\r (no-eol) (esc) (reposimplestore !)
-  linking [              <=>                             ] 14\r (no-eol) (esc) (reposimplestore !)
-  linking [               <=>                            ] 15\r (no-eol) (esc) (reposimplestore !)
-  linking [                <=>                           ] 16\r (no-eol) (esc) (reposimplestore !)
+  linking [====>                                        ] 1/8\r (no-eol) (esc)
+  linking [==========>                                  ] 2/8\r (no-eol) (esc)
+  linking [===============>                             ] 3/8\r (no-eol) (esc)
+  linking [=====================>                       ] 4/8\r (no-eol) (esc)
+  linking [===========================>                 ] 5/8\r (no-eol) (esc)
+  linking [================================>            ] 6/8\r (no-eol) (esc)
+  linking [======================================>      ] 7/8\r (no-eol) (esc)
+  linking [============================================>] 8/8\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (foo) [                                     ] 0/3\r (no-eol) (esc)
   archiving (foo) [===========>                         ] 1/3\r (no-eol) (esc)
   archiving (foo) [=======================>             ] 2/3\r (no-eol) (esc)
   archiving (foo) [====================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
-  linking [ <=>                                           ] 1\r (no-eol) (esc)
-  linking [  <=>                                          ] 2\r (no-eol) (esc)
-  linking [   <=>                                         ] 3\r (no-eol) (esc)
-  linking [    <=>                                        ] 4\r (no-eol) (esc)
-  linking [     <=>                                       ] 5\r (no-eol) (esc)
-  linking [      <=>                                      ] 6\r (no-eol) (esc)
-  linking [       <=>                                     ] 7\r (no-eol) (esc) (reposimplestore !)
-  linking [        <=>                                    ] 8\r (no-eol) (esc) (reposimplestore !)
-  linking [         <=>                                   ] 9\r (no-eol) (esc) (reposimplestore !)
+  linking [======>                                      ] 1/6\r (no-eol) (esc)
+  linking [==============>                              ] 2/6\r (no-eol) (esc)
+  linking [=====================>                       ] 3/6\r (no-eol) (esc)
+  linking [=============================>               ] 4/6\r (no-eol) (esc)
+  linking [====================================>        ] 5/6\r (no-eol) (esc)
+  linking [============================================>] 6/6\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (foo/bar) [                                 ] 0/1\r (no-eol) (esc)
   archiving (foo/bar) [================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   cloning subrepo foo from $TESTTMP/repo/foo
   cloning subrepo foo/bar from $TESTTMP/repo/foo/bar
 #else
 Note there's a slight output glitch on non-hardlink systems: the last
 "linking" progress topic never gets closed, leading to slight output corruption on that platform.
   $ hg archive --subrepos -r tip --prefix './' ../archive.tar.gz
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   linking [ <=>                                           ] 1\r (no-eol) (esc)
   cloning subrepo foo/bar from $TESTTMP/repo/foo/bar
 #endif
 
 Archive + subrepos uses '/' for all component separators
 
   $ tar -tzf ../archive.tar.gz | sort
   .hg_archival.txt
   .hgsub
   .hgsubstate
   foo/.hgsub
   foo/.hgsubstate
   foo/bar/z.txt
   foo/y.txt
   x.txt
 
 The newly cloned subrepos contain no working copy:
 
   $ hg -R foo summary
   parent: -1:000000000000  (no revision checked out)
   branch: default
   commit: (clean)
   update: 4 new changesets (update)
 
 Sharing a local repo with missing local subrepos (i.e. it was never updated
 from null) works because the default path is copied from the source repo,
 whereas clone should fail.
 
   $ hg --config progress.disable=True clone -U ../empty ../empty2
 
   $ hg --config extensions.share= --config progress.disable=True \
   >    share ../empty2 ../empty_share
   updating working directory
   sharing subrepo foo from $TESTTMP/empty/foo
   sharing subrepo foo/bar from $TESTTMP/empty/foo/bar
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg --config progress.disable=True clone ../empty2 ../empty_clone
   updating to branch default
   cloning subrepo foo from $TESTTMP/empty2/foo
   abort: repository $TESTTMP/empty2/foo not found
   [255]
 
 Disable progress extension and cleanup:
 
   $ mv $HGRCPATH.no-progress $HGRCPATH
 
 Test archiving when there is a directory in the way for a subrepo
 created by archive:
 
   $ hg clone -U . ../almost-empty
   $ cd ../almost-empty
   $ mkdir foo
   $ echo f > foo/f
   $ hg archive --subrepos -r tip archive
   cloning subrepo foo from $TESTTMP/empty/foo
   abort: destination '$TESTTMP/almost-empty/foo' is not empty (in subrepository "foo")
   [255]
 
 Clone and test outgoing:
 
   $ cd ..
   $ hg clone repo repo2
   updating to branch default
   cloning subrepo foo from $TESTTMP/repo/foo
   cloning subrepo foo/bar from $TESTTMP/repo/foo/bar
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd repo2
   $ hg outgoing -S
   comparing with $TESTTMP/repo
   searching for changes
   no changes found
   comparing with $TESTTMP/repo/foo
   searching for changes
   no changes found
   comparing with $TESTTMP/repo/foo/bar
   searching for changes
   no changes found
   [1]
 
 Make nested change:
 
   $ echo y4 >> foo/y.txt
   $ hg diff --nodates -S
   diff -r 65903cebad86 foo/y.txt
   --- a/foo/y.txt
   +++ b/foo/y.txt
   @@ -1,3 +1,4 @@
    y1
    y2
    y3
   +y4
   $ hg commit --subrepos -m 3-4-2
   committing subrepository foo
   $ hg outgoing -S
   comparing with $TESTTMP/repo
   searching for changes
   changeset:   3:2655b8ecc4ee
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     3-4-2
   
   comparing with $TESTTMP/repo/foo
   searching for changes
   changeset:   4:e96193d6cb36
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     3-4-2
   
   comparing with $TESTTMP/repo/foo/bar
   searching for changes
   no changes found
 
 
 Switch to original repo and setup default path:
 
   $ cd ../repo
   $ echo '[paths]' >> .hg/hgrc
   $ echo 'default = ../repo2' >> .hg/hgrc
 
 Test incoming:
 
   $ hg incoming -S
   comparing with $TESTTMP/repo2
   searching for changes
   changeset:   3:2655b8ecc4ee
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     3-4-2
   
   comparing with $TESTTMP/repo2/foo
   searching for changes
   changeset:   4:e96193d6cb36
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     3-4-2
   
   comparing with $TESTTMP/repo2/foo/bar
   searching for changes
   no changes found
 
   $ hg incoming -S --bundle incoming.hg
   abort: cannot specify both --subrepos and --bundle
   [10]
 
 Test missing subrepo:
 
   $ rm -r foo
   $ hg status -S
   warning: error "unknown revision '65903cebad86f1a84bd4f1134f62fa7dcb7a1c98'" in subrepository "foo"
 
 Issue2619: IndexError: list index out of range on hg add with subrepos
 The subrepo must sorts after the explicit filename.
 
   $ cd ..
   $ hg init test
   $ cd test
   $ hg init x
   $ echo abc > abc.txt
   $ hg ci -Am "abc"
   adding abc.txt
   $ echo "x = x" >> .hgsub
   $ hg add .hgsub
   $ touch a x/a
   $ hg add a x/a
 
   $ hg ci -Sm "added x"
   committing subrepository x
   $ echo abc > x/a
   $ hg revert --rev '.^' "set:subrepo('glob:x*')"
   abort: subrepository 'x' does not exist in 25ac2c9b3180!
   [255]
 
   $ cd ..