store: exclude `undo.` nodemap's file from `walk`

There are "temporary" local file that we should not be transfered by `walk` user
like local clone and stream clone.

This fix the small issue that the new tests highlighted.

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

mercurial/store.py

@@ -1,810 +1,814 b''
 # store.py - repository store handling for Mercurial
 #
 # Copyright 2008 Olivia Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import errno
 import functools
 import os
+import re
 import stat
 
 from .i18n import _
 from .pycompat import getattr
 from .node import hex
 from . import (
     changelog,
     error,
     manifest,
     policy,
     pycompat,
     util,
     vfs as vfsmod,
 )
 from .utils import hashutil
 
 parsers = policy.importmod('parsers')
 # how much bytes should be read from fncache in one read
 # It is done to prevent loading large fncache files into memory
 fncache_chunksize = 10 ** 6
 
 
 def _matchtrackedpath(path, matcher):
     """parses a fncache entry and returns whether the entry is tracking a path
     matched by matcher or not.
 
     If matcher is None, returns True"""
 
     if matcher is None:
         return True
     path = decodedir(path)
     if path.startswith(b'data/'):
         return matcher(path[len(b'data/') : -len(b'.i')])
     elif path.startswith(b'meta/'):
         return matcher.visitdir(path[len(b'meta/') : -len(b'/00manifest.i')])
 
     raise error.ProgrammingError(b"cannot decode path %s" % path)
 
 
 # This avoids a collision between a file named foo and a dir named
 # foo.i or foo.d
 def _encodedir(path):
     """
     >>> _encodedir(b'data/foo.i')
     'data/foo.i'
     >>> _encodedir(b'data/foo.i/bla.i')
     'data/foo.i.hg/bla.i'
     >>> _encodedir(b'data/foo.i.hg/bla.i')
     'data/foo.i.hg.hg/bla.i'
     >>> _encodedir(b'data/foo.i\\ndata/foo.i/bla.i\\ndata/foo.i.hg/bla.i\\n')
     'data/foo.i\\ndata/foo.i.hg/bla.i\\ndata/foo.i.hg.hg/bla.i\\n'
     """
     return (
         path.replace(b".hg/", b".hg.hg/")
         .replace(b".i/", b".i.hg/")
         .replace(b".d/", b".d.hg/")
     )
 
 
 encodedir = getattr(parsers, 'encodedir', _encodedir)
 
 
 def decodedir(path):
     """
     >>> decodedir(b'data/foo.i')
     'data/foo.i'
     >>> decodedir(b'data/foo.i.hg/bla.i')
     'data/foo.i/bla.i'
     >>> decodedir(b'data/foo.i.hg.hg/bla.i')
     'data/foo.i.hg/bla.i'
     """
     if b".hg/" not in path:
         return path
     return (
         path.replace(b".d.hg/", b".d/")
         .replace(b".i.hg/", b".i/")
         .replace(b".hg.hg/", b".hg/")
     )
 
 
 def _reserved():
     """characters that are problematic for filesystems
 
     * ascii escapes (0..31)
     * ascii hi (126..255)
     * windows specials
 
     these characters will be escaped by encodefunctions
     """
     winreserved = [ord(x) for x in u'\\:*?"<>|']
     for x in range(32):
         yield x
     for x in range(126, 256):
         yield x
     for x in winreserved:
         yield x
 
 
 def _buildencodefun():
     """
     >>> enc, dec = _buildencodefun()
 
     >>> enc(b'nothing/special.txt')
     'nothing/special.txt'
     >>> dec(b'nothing/special.txt')
     'nothing/special.txt'
 
     >>> enc(b'HELLO')
     '_h_e_l_l_o'
     >>> dec(b'_h_e_l_l_o')
     'HELLO'
 
     >>> enc(b'hello:world?')
     'hello~3aworld~3f'
     >>> dec(b'hello~3aworld~3f')
     'hello:world?'
 
     >>> enc(b'the\\x07quick\\xADshot')
     'the~07quick~adshot'
     >>> dec(b'the~07quick~adshot')
     'the\\x07quick\\xadshot'
     """
     e = b'_'
     xchr = pycompat.bytechr
     asciistr = list(map(xchr, range(127)))
     capitals = list(range(ord(b"A"), ord(b"Z") + 1))
 
     cmap = {x: x for x in asciistr}
     for x in _reserved():
         cmap[xchr(x)] = b"~%02x" % x
     for x in capitals + [ord(e)]:
         cmap[xchr(x)] = e + xchr(x).lower()
 
     dmap = {}
     for k, v in pycompat.iteritems(cmap):
         dmap[v] = k
 
     def decode(s):
         i = 0
         while i < len(s):
             for l in pycompat.xrange(1, 4):
                 try:
                     yield dmap[s[i : i + l]]
                     i += l
                     break
                 except KeyError:
                     pass
             else:
                 raise KeyError
 
     return (
         lambda s: b''.join(
             [cmap[s[c : c + 1]] for c in pycompat.xrange(len(s))]
         ),
         lambda s: b''.join(list(decode(s))),
     )
 
 
 _encodefname, _decodefname = _buildencodefun()
 
 
 def encodefilename(s):
     """
     >>> encodefilename(b'foo.i/bar.d/bla.hg/hi:world?/HELLO')
     'foo.i.hg/bar.d.hg/bla.hg.hg/hi~3aworld~3f/_h_e_l_l_o'
     """
     return _encodefname(encodedir(s))
 
 
 def decodefilename(s):
     """
     >>> decodefilename(b'foo.i.hg/bar.d.hg/bla.hg.hg/hi~3aworld~3f/_h_e_l_l_o')
     'foo.i/bar.d/bla.hg/hi:world?/HELLO'
     """
     return decodedir(_decodefname(s))
 
 
 def _buildlowerencodefun():
     """
     >>> f = _buildlowerencodefun()
     >>> f(b'nothing/special.txt')
     'nothing/special.txt'
     >>> f(b'HELLO')
     'hello'
     >>> f(b'hello:world?')
     'hello~3aworld~3f'
     >>> f(b'the\\x07quick\\xADshot')
     'the~07quick~adshot'
     """
     xchr = pycompat.bytechr
     cmap = {xchr(x): xchr(x) for x in pycompat.xrange(127)}
     for x in _reserved():
         cmap[xchr(x)] = b"~%02x" % x
     for x in range(ord(b"A"), ord(b"Z") + 1):
         cmap[xchr(x)] = xchr(x).lower()
 
     def lowerencode(s):
         return b"".join([cmap[c] for c in pycompat.iterbytestr(s)])
 
     return lowerencode
 
 
 lowerencode = getattr(parsers, 'lowerencode', None) or _buildlowerencodefun()
 
 # Windows reserved names: con, prn, aux, nul, com1..com9, lpt1..lpt9
 _winres3 = (b'aux', b'con', b'prn', b'nul')  # length 3
 _winres4 = (b'com', b'lpt')  # length 4 (with trailing 1..9)
 
 
 def _auxencode(path, dotencode):
     """
     Encodes filenames containing names reserved by Windows or which end in
     period or space. Does not touch other single reserved characters c.
     Specifically, c in '\\:*?"<>|' or ord(c) <= 31 are *not* encoded here.
     Additionally encodes space or period at the beginning, if dotencode is
     True. Parameter path is assumed to be all lowercase.
     A segment only needs encoding if a reserved name appears as a
     basename (e.g. "aux", "aux.foo"). A directory or file named "foo.aux"
     doesn't need encoding.
 
     >>> s = b'.foo/aux.txt/txt.aux/con/prn/nul/foo.'
     >>> _auxencode(s.split(b'/'), True)
     ['~2efoo', 'au~78.txt', 'txt.aux', 'co~6e', 'pr~6e', 'nu~6c', 'foo~2e']
     >>> s = b'.com1com2/lpt9.lpt4.lpt1/conprn/com0/lpt0/foo.'
     >>> _auxencode(s.split(b'/'), False)
     ['.com1com2', 'lp~749.lpt4.lpt1', 'conprn', 'com0', 'lpt0', 'foo~2e']
     >>> _auxencode([b'foo. '], True)
     ['foo.~20']
     >>> _auxencode([b' .foo'], True)
     ['~20.foo']
     """
     for i, n in enumerate(path):
         if not n:
             continue
         if dotencode and n[0] in b'. ':
             n = b"~%02x" % ord(n[0:1]) + n[1:]
             path[i] = n
         else:
             l = n.find(b'.')
             if l == -1:
                 l = len(n)
             if (l == 3 and n[:3] in _winres3) or (
                 l == 4
                 and n[3:4] <= b'9'
                 and n[3:4] >= b'1'
                 and n[:3] in _winres4
             ):
                 # encode third letter ('aux' -> 'au~78')
                 ec = b"~%02x" % ord(n[2:3])
                 n = n[0:2] + ec + n[3:]
                 path[i] = n
         if n[-1] in b'. ':
             # encode last period or space ('foo...' -> 'foo..~2e')
             path[i] = n[:-1] + b"~%02x" % ord(n[-1:])
     return path
 
 
 _maxstorepathlen = 120
 _dirprefixlen = 8
 _maxshortdirslen = 8 * (_dirprefixlen + 1) - 4
 
 
 def _hashencode(path, dotencode):
     digest = hex(hashutil.sha1(path).digest())
     le = lowerencode(path[5:]).split(b'/')  # skips prefix 'data/' or 'meta/'
     parts = _auxencode(le, dotencode)
     basename = parts[-1]
     _root, ext = os.path.splitext(basename)
     sdirs = []
     sdirslen = 0
     for p in parts[:-1]:
         d = p[:_dirprefixlen]
         if d[-1] in b'. ':
             # Windows can't access dirs ending in period or space
             d = d[:-1] + b'_'
         if sdirslen == 0:
             t = len(d)
         else:
             t = sdirslen + 1 + len(d)
             if t > _maxshortdirslen:
                 break
         sdirs.append(d)
         sdirslen = t
     dirs = b'/'.join(sdirs)
     if len(dirs) > 0:
         dirs += b'/'
     res = b'dh/' + dirs + digest + ext
     spaceleft = _maxstorepathlen - len(res)
     if spaceleft > 0:
         filler = basename[:spaceleft]
         res = b'dh/' + dirs + filler + digest + ext
     return res
 
 
 def _hybridencode(path, dotencode):
     """encodes path with a length limit
 
     Encodes all paths that begin with 'data/', according to the following.
 
     Default encoding (reversible):
 
     Encodes all uppercase letters 'X' as '_x'. All reserved or illegal
     characters are encoded as '~xx', where xx is the two digit hex code
     of the character (see encodefilename).
     Relevant path components consisting of Windows reserved filenames are
     masked by encoding the third character ('aux' -> 'au~78', see _auxencode).
 
     Hashed encoding (not reversible):
 
     If the default-encoded path is longer than _maxstorepathlen, a
     non-reversible hybrid hashing of the path is done instead.
     This encoding uses up to _dirprefixlen characters of all directory
     levels of the lowerencoded path, but not more levels than can fit into
     _maxshortdirslen.
     Then follows the filler followed by the sha digest of the full path.
     The filler is the beginning of the basename of the lowerencoded path
     (the basename is everything after the last path separator). The filler
     is as long as possible, filling in characters from the basename until
     the encoded path has _maxstorepathlen characters (or all chars of the
     basename have been taken).
     The extension (e.g. '.i' or '.d') is preserved.
 
     The string 'data/' at the beginning is replaced with 'dh/', if the hashed
     encoding was used.
     """
     path = encodedir(path)
     ef = _encodefname(path).split(b'/')
     res = b'/'.join(_auxencode(ef, dotencode))
     if len(res) > _maxstorepathlen:
         res = _hashencode(path, dotencode)
     return res
 
 
 def _pathencode(path):
     de = encodedir(path)
     if len(path) > _maxstorepathlen:
         return _hashencode(de, True)
     ef = _encodefname(de).split(b'/')
     res = b'/'.join(_auxencode(ef, True))
     if len(res) > _maxstorepathlen:
         return _hashencode(de, True)
     return res
 
 
 _pathencode = getattr(parsers, 'pathencode', _pathencode)
 
 
 def _plainhybridencode(f):
     return _hybridencode(f, False)
 
 
 def _calcmode(vfs):
     try:
         # files in .hg/ will be created using this mode
         mode = vfs.stat().st_mode
         # avoid some useless chmods
         if (0o777 & ~util.umask) == (0o777 & mode):
             mode = None
     except OSError:
         mode = None
     return mode
 
 
 _data = [
     b'bookmarks',
     b'narrowspec',
     b'data',
     b'meta',
     b'00manifest.d',
     b'00manifest.i',
     b'00changelog.d',
     b'00changelog.i',
     b'phaseroots',
     b'obsstore',
     b'requires',
 ]
 
 REVLOG_FILES_MAIN_EXT = (b'.i', b'i.tmpcensored')
 REVLOG_FILES_OTHER_EXT = (b'.d', b'.n', b'.nd', b'd.tmpcensored')
 # files that are "volatile" and might change between listing and streaming
 #
 # note: the ".nd" file are nodemap data and won't "change" but they might be
 # deleted.
 REVLOG_FILES_VOLATILE_EXT = (b'.n', b'.nd')
 
+# some exception to the above matching
+EXCLUDED = re.compile(b'.*undo\.[^/]+\.nd?$')
+
 
 def is_revlog(f, kind, st):
     if kind != stat.S_IFREG:
         return None
     return revlog_type(f)
 
 
 def revlog_type(f):
     if f.endswith(REVLOG_FILES_MAIN_EXT):
         return FILEFLAGS_REVLOG_MAIN
-    elif f.endswith(REVLOG_FILES_OTHER_EXT):
+    elif f.endswith(REVLOG_FILES_OTHER_EXT) and EXCLUDED.match(f) is None:
         t = FILETYPE_FILELOG_OTHER
         if f.endswith(REVLOG_FILES_VOLATILE_EXT):
             t |= FILEFLAGS_VOLATILE
         return t
 
 
 # the file is part of changelog data
 FILEFLAGS_CHANGELOG = 1 << 13
 # the file is part of manifest data
 FILEFLAGS_MANIFESTLOG = 1 << 12
 # the file is part of filelog data
 FILEFLAGS_FILELOG = 1 << 11
 # file that are not directly part of a revlog
 FILEFLAGS_OTHER = 1 << 10
 
 # the main entry point for a revlog
 FILEFLAGS_REVLOG_MAIN = 1 << 1
 # a secondary file for a revlog
 FILEFLAGS_REVLOG_OTHER = 1 << 0
 
 # files that are "volatile" and might change between listing and streaming
 FILEFLAGS_VOLATILE = 1 << 20
 
 FILETYPE_CHANGELOG_MAIN = FILEFLAGS_CHANGELOG | FILEFLAGS_REVLOG_MAIN
 FILETYPE_CHANGELOG_OTHER = FILEFLAGS_CHANGELOG | FILEFLAGS_REVLOG_OTHER
 FILETYPE_MANIFESTLOG_MAIN = FILEFLAGS_MANIFESTLOG | FILEFLAGS_REVLOG_MAIN
 FILETYPE_MANIFESTLOG_OTHER = FILEFLAGS_MANIFESTLOG | FILEFLAGS_REVLOG_OTHER
 FILETYPE_FILELOG_MAIN = FILEFLAGS_FILELOG | FILEFLAGS_REVLOG_MAIN
 FILETYPE_FILELOG_OTHER = FILEFLAGS_FILELOG | FILEFLAGS_REVLOG_OTHER
 FILETYPE_OTHER = FILEFLAGS_OTHER
 
 
 class basicstore(object):
     '''base class for local repository stores'''
 
     def __init__(self, path, vfstype):
         vfs = vfstype(path)
         self.path = vfs.base
         self.createmode = _calcmode(vfs)
         vfs.createmode = self.createmode
         self.rawvfs = vfs
         self.vfs = vfsmod.filtervfs(vfs, encodedir)
         self.opener = self.vfs
 
     def join(self, f):
         return self.path + b'/' + encodedir(f)
 
     def _walk(self, relpath, recurse):
         '''yields (unencoded, encoded, size)'''
         path = self.path
         if relpath:
             path += b'/' + relpath
         striplen = len(self.path) + 1
         l = []
         if self.rawvfs.isdir(path):
             visit = [path]
             readdir = self.rawvfs.readdir
             while visit:
                 p = visit.pop()
                 for f, kind, st in readdir(p, stat=True):
                     fp = p + b'/' + f
                     rl_type = is_revlog(f, kind, st)
                     if rl_type is not None:
                         n = util.pconvert(fp[striplen:])
                         l.append((rl_type, decodedir(n), n, st.st_size))
                     elif kind == stat.S_IFDIR and recurse:
                         visit.append(fp)
         l.sort()
         return l
 
     def changelog(self, trypending, concurrencychecker=None):
         return changelog.changelog(
             self.vfs,
             trypending=trypending,
             concurrencychecker=concurrencychecker,
         )
 
     def manifestlog(self, repo, storenarrowmatch):
         rootstore = manifest.manifestrevlog(repo.nodeconstants, self.vfs)
         return manifest.manifestlog(self.vfs, repo, rootstore, storenarrowmatch)
 
     def datafiles(self, matcher=None):
         files = self._walk(b'data', True) + self._walk(b'meta', True)
         for (t, u, e, s) in files:
             yield (FILEFLAGS_FILELOG | t, u, e, s)
 
     def topfiles(self):
         # yield manifest before changelog
         files = reversed(self._walk(b'', False))
         for (t, u, e, s) in files:
             if u.startswith(b'00changelog'):
                 yield (FILEFLAGS_CHANGELOG | t, u, e, s)
             elif u.startswith(b'00manifest'):
                 yield (FILEFLAGS_MANIFESTLOG | t, u, e, s)
             else:
                 yield (FILETYPE_OTHER | t, u, e, s)
 
     def walk(self, matcher=None):
         """return file related to data storage (ie: revlogs)
 
         yields (file_type, unencoded, encoded, size)
 
         if a matcher is passed, storage files of only those tracked paths
         are passed with matches the matcher
         """
         # yield data files first
         for x in self.datafiles(matcher):
             yield x
         for x in self.topfiles():
             yield x
 
     def copylist(self):
         return _data
 
     def write(self, tr):
         pass
 
     def invalidatecaches(self):
         pass
 
     def markremoved(self, fn):
         pass
 
     def __contains__(self, path):
         '''Checks if the store contains path'''
         path = b"/".join((b"data", path))
         # file?
         if self.vfs.exists(path + b".i"):
             return True
         # dir?
         if not path.endswith(b"/"):
             path = path + b"/"
         return self.vfs.exists(path)
 
 
 class encodedstore(basicstore):
     def __init__(self, path, vfstype):
         vfs = vfstype(path + b'/store')
         self.path = vfs.base
         self.createmode = _calcmode(vfs)
         vfs.createmode = self.createmode
         self.rawvfs = vfs
         self.vfs = vfsmod.filtervfs(vfs, encodefilename)
         self.opener = self.vfs
 
     def datafiles(self, matcher=None):
         for t, a, b, size in super(encodedstore, self).datafiles():
             try:
                 a = decodefilename(a)
             except KeyError:
                 a = None
             if a is not None and not _matchtrackedpath(a, matcher):
                 continue
             yield t, a, b, size
 
     def join(self, f):
         return self.path + b'/' + encodefilename(f)
 
     def copylist(self):
         return [b'requires', b'00changelog.i'] + [b'store/' + f for f in _data]
 
 
 class fncache(object):
     # the filename used to be partially encoded
     # hence the encodedir/decodedir dance
     def __init__(self, vfs):
         self.vfs = vfs
         self.entries = None
         self._dirty = False
         # set of new additions to fncache
         self.addls = set()
 
     def ensureloaded(self, warn=None):
         """read the fncache file if not already read.
 
         If the file on disk is corrupted, raise. If warn is provided,
         warn and keep going instead."""
         if self.entries is None:
             self._load(warn)
 
     def _load(self, warn=None):
         '''fill the entries from the fncache file'''
         self._dirty = False
         try:
             fp = self.vfs(b'fncache', mode=b'rb')
         except IOError:
             # skip nonexistent file
             self.entries = set()
             return
 
         self.entries = set()
         chunk = b''
         for c in iter(functools.partial(fp.read, fncache_chunksize), b''):
             chunk += c
             try:
                 p = chunk.rindex(b'\n')
                 self.entries.update(decodedir(chunk[: p + 1]).splitlines())
                 chunk = chunk[p + 1 :]
             except ValueError:
                 # substring '\n' not found, maybe the entry is bigger than the
                 # chunksize, so let's keep iterating
                 pass
 
         if chunk:
             msg = _(b"fncache does not ends with a newline")
             if warn:
                 warn(msg + b'\n')
             else:
                 raise error.Abort(
                     msg,
                     hint=_(
                         b"use 'hg debugrebuildfncache' to "
                         b"rebuild the fncache"
                     ),
                 )
         self._checkentries(fp, warn)
         fp.close()
 
     def _checkentries(self, fp, warn):
         """ make sure there is no empty string in entries """
         if b'' in self.entries:
             fp.seek(0)
             for n, line in enumerate(util.iterfile(fp)):
                 if not line.rstrip(b'\n'):
                     t = _(b'invalid entry in fncache, line %d') % (n + 1)
                     if warn:
                         warn(t + b'\n')
                     else:
                         raise error.Abort(t)
 
     def write(self, tr):
         if self._dirty:
             assert self.entries is not None
             self.entries = self.entries | self.addls
             self.addls = set()
             tr.addbackup(b'fncache')
             fp = self.vfs(b'fncache', mode=b'wb', atomictemp=True)
             if self.entries:
                 fp.write(encodedir(b'\n'.join(self.entries) + b'\n'))
             fp.close()
             self._dirty = False
         if self.addls:
             # if we have just new entries, let's append them to the fncache
             tr.addbackup(b'fncache')
             fp = self.vfs(b'fncache', mode=b'ab', atomictemp=True)
             if self.addls:
                 fp.write(encodedir(b'\n'.join(self.addls) + b'\n'))
             fp.close()
             self.entries = None
             self.addls = set()
 
     def add(self, fn):
         if self.entries is None:
             self._load()
         if fn not in self.entries:
             self.addls.add(fn)
 
     def remove(self, fn):
         if self.entries is None:
             self._load()
         if fn in self.addls:
             self.addls.remove(fn)
             return
         try:
             self.entries.remove(fn)
             self._dirty = True
         except KeyError:
             pass
 
     def __contains__(self, fn):
         if fn in self.addls:
             return True
         if self.entries is None:
             self._load()
         return fn in self.entries
 
     def __iter__(self):
         if self.entries is None:
             self._load()
         return iter(self.entries | self.addls)
 
 
 class _fncachevfs(vfsmod.proxyvfs):
     def __init__(self, vfs, fnc, encode):
         vfsmod.proxyvfs.__init__(self, vfs)
         self.fncache = fnc
         self.encode = encode
 
     def __call__(self, path, mode=b'r', *args, **kw):
         encoded = self.encode(path)
         if mode not in (b'r', b'rb') and (
             path.startswith(b'data/') or path.startswith(b'meta/')
         ):
             # do not trigger a fncache load when adding a file that already is
             # known to exist.
             notload = self.fncache.entries is None and self.vfs.exists(encoded)
             if notload and b'a' in mode and not self.vfs.stat(encoded).st_size:
                 # when appending to an existing file, if the file has size zero,
                 # it should be considered as missing. Such zero-size files are
                 # the result of truncation when a transaction is aborted.
                 notload = False
             if not notload:
                 self.fncache.add(path)
         return self.vfs(encoded, mode, *args, **kw)
 
     def join(self, path):
         if path:
             return self.vfs.join(self.encode(path))
         else:
             return self.vfs.join(path)
 
 
 class fncachestore(basicstore):
     def __init__(self, path, vfstype, dotencode):
         if dotencode:
             encode = _pathencode
         else:
             encode = _plainhybridencode
         self.encode = encode
         vfs = vfstype(path + b'/store')
         self.path = vfs.base
         self.pathsep = self.path + b'/'
         self.createmode = _calcmode(vfs)
         vfs.createmode = self.createmode
         self.rawvfs = vfs
         fnc = fncache(vfs)
         self.fncache = fnc
         self.vfs = _fncachevfs(vfs, fnc, encode)
         self.opener = self.vfs
 
     def join(self, f):
         return self.pathsep + self.encode(f)
 
     def getsize(self, path):
         return self.rawvfs.stat(path).st_size
 
     def datafiles(self, matcher=None):
         for f in sorted(self.fncache):
             if not _matchtrackedpath(f, matcher):
                 continue
             ef = self.encode(f)
             try:
                 t = revlog_type(f)
                 t |= FILEFLAGS_FILELOG
                 yield t, f, ef, self.getsize(ef)
             except OSError as err:
                 if err.errno != errno.ENOENT:
                     raise
 
     def copylist(self):
         d = (
             b'bookmarks',
             b'narrowspec',
             b'data',
             b'meta',
             b'dh',
             b'fncache',
             b'phaseroots',
             b'obsstore',
             b'00manifest.d',
             b'00manifest.i',
             b'00changelog.d',
             b'00changelog.i',
             b'requires',
         )
         return [b'requires', b'00changelog.i'] + [b'store/' + f for f in d]
 
     def write(self, tr):
         self.fncache.write(tr)
 
     def invalidatecaches(self):
         self.fncache.entries = None
         self.fncache.addls = set()
 
     def markremoved(self, fn):
         self.fncache.remove(fn)
 
     def _exists(self, f):
         ef = self.encode(f)
         try:
             self.getsize(ef)
             return True
         except OSError as err:
             if err.errno != errno.ENOENT:
                 raise
             # nonexistent entry
             return False
 
     def __contains__(self, path):
         '''Checks if the store contains path'''
         path = b"/".join((b"data", path))
         # check for files (exact match)
         e = path + b'.i'
         if e in self.fncache and self._exists(e):
             return True
         # now check for directories (prefix match)
         if not path.endswith(b'/'):
             path += b'/'
         for e in self.fncache:
             if e.startswith(path) and self._exists(e):
                 return True
         return False

tests/test-persistent-nodemap.t

@@ -1,1054 +1,1052 b''
 ===================================
 Test the persistent on-disk nodemap
 ===================================
 
 
 #if no-rust
 
   $ cat << EOF >> $HGRCPATH
   > [format]
   > use-persistent-nodemap=yes
   > [devel]
   > persistent-nodemap=yes
   > EOF
 
 #endif
 
   $ hg init test-repo --config storage.revlog.persistent-nodemap.slow-path=allow
   $ cd test-repo
 
 Check handling of the default slow-path value
 
 #if no-pure no-rust
 
   $ hg id
   abort: accessing `persistent-nodemap` repository without associated fast implementation.
   (check `hg help config.format.use-persistent-nodemap` for details)
   [255]
 
 Unlock further check (we are here to test the feature)
 
   $ cat << EOF >> $HGRCPATH
   > [storage]
   > # to avoid spamming the test
   > revlog.persistent-nodemap.slow-path=allow
   > EOF
 
 #endif
 
 #if rust
 
 Regression test for a previous bug in Rust/C FFI for the `Revlog_CAPI` capsule:
 in places where `mercurial/cext/revlog.c` function signatures use `Py_ssize_t`
 (64 bits on Linux x86_64), corresponding declarations in `rust/hg-cpython/src/cindex.rs`
 incorrectly used `libc::c_int` (32 bits).
 As a result, -1 passed from Rust for the null revision became 4294967295 in C.
 
   $ hg log -r 00000000
   changeset:   -1:000000000000
   tag:         tip
   user:        
   date:        Thu Jan 01 00:00:00 1970 +0000
   
 
 #endif
 
 
   $ hg debugformat
   format-variant     repo
   fncache:            yes
   dotencode:          yes
   generaldelta:       yes
   share-safe:          no
   sparserevlog:       yes
   persistent-nodemap: yes
   copies-sdc:          no
   revlog-v2:           no
   plain-cl-delta:     yes
   compression:        zlib (no-zstd !)
   compression:        zstd (zstd !)
   compression-level:  default
   $ hg debugbuilddag .+5000 --new-file
 
   $ hg debugnodemap --metadata
   uid: ???????????????? (glob)
   tip-rev: 5000
   tip-node: 6b02b8c7b96654c25e86ba69eda198d7e6ad8b3c
   data-length: 121088
   data-unused: 0
   data-unused: 0.000%
   $ f --size .hg/store/00changelog.n
   .hg/store/00changelog.n: size=70
 
 Simple lookup works
 
   $ ANYNODE=`hg log --template '{node|short}\n' --rev tip`
   $ hg log -r "$ANYNODE" --template '{rev}\n'
   5000
 
 
 #if rust
 
   $ f --sha256 .hg/store/00changelog-*.nd
   .hg/store/00changelog-????????????????.nd: sha256=2e029d3200bd1a986b32784fc2ef1a3bd60dc331f025718bcf5ff44d93f026fd (glob)
 
   $ f --sha256 .hg/store/00manifest-*.nd
   .hg/store/00manifest-????????????????.nd: sha256=97117b1c064ea2f86664a124589e47db0e254e8d34739b5c5cc5bf31c9da2b51 (glob)
   $ hg debugnodemap --dump-new | f --sha256 --size
   size=121088, sha256=2e029d3200bd1a986b32784fc2ef1a3bd60dc331f025718bcf5ff44d93f026fd
   $ hg debugnodemap --dump-disk | f --sha256 --bytes=256 --hexdump --size
   size=121088, sha256=2e029d3200bd1a986b32784fc2ef1a3bd60dc331f025718bcf5ff44d93f026fd
   0000: 00 00 00 91 00 00 00 20 00 00 00 bb 00 00 00 e7 |....... ........|
   0010: 00 00 00 66 00 00 00 a1 00 00 01 13 00 00 01 22 |...f..........."|
   0020: 00 00 00 23 00 00 00 fc 00 00 00 ba 00 00 00 5e |...#...........^|
   0030: 00 00 00 df 00 00 01 4e 00 00 01 65 00 00 00 ab |.......N...e....|
   0040: 00 00 00 a9 00 00 00 95 00 00 00 73 00 00 00 38 |...........s...8|
   0050: 00 00 00 cc 00 00 00 92 00 00 00 90 00 00 00 69 |...............i|
   0060: 00 00 00 ec 00 00 00 8d 00 00 01 4f 00 00 00 12 |...........O....|
   0070: 00 00 02 0c 00 00 00 77 00 00 00 9c 00 00 00 8f |.......w........|
   0080: 00 00 00 d5 00 00 00 6b 00 00 00 48 00 00 00 b3 |.......k...H....|
   0090: 00 00 00 e5 00 00 00 b5 00 00 00 8e 00 00 00 ad |................|
   00a0: 00 00 00 7b 00 00 00 7c 00 00 00 0b 00 00 00 2b |...{...|.......+|
   00b0: 00 00 00 c6 00 00 00 1e 00 00 01 08 00 00 00 11 |................|
   00c0: 00 00 01 30 00 00 00 26 00 00 01 9c 00 00 00 35 |...0...&.......5|
   00d0: 00 00 00 b8 00 00 01 31 00 00 00 2c 00 00 00 55 |.......1...,...U|
   00e0: 00 00 00 8a 00 00 00 9a 00 00 00 0c 00 00 01 1e |................|
   00f0: 00 00 00 a4 00 00 00 83 00 00 00 c9 00 00 00 8c |................|
 
 
 #else
 
   $ f --sha256 .hg/store/00changelog-*.nd
   .hg/store/00changelog-????????????????.nd: sha256=f544f5462ff46097432caf6d764091f6d8c46d6121be315ead8576d548c9dd79 (glob)
   $ hg debugnodemap --dump-new | f --sha256 --size
   size=121088, sha256=f544f5462ff46097432caf6d764091f6d8c46d6121be315ead8576d548c9dd79
   $ hg debugnodemap --dump-disk | f --sha256 --bytes=256 --hexdump --size
   size=121088, sha256=f544f5462ff46097432caf6d764091f6d8c46d6121be315ead8576d548c9dd79
   0000: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff |................|
   0010: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff |................|
   0020: ff ff ff ff ff ff f5 06 ff ff ff ff ff ff f3 e7 |................|
   0030: ff ff ef ca ff ff ff ff ff ff ff ff ff ff ff ff |................|
   0040: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff |................|
   0050: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ed 08 |................|
   0060: ff ff ed 66 ff ff ff ff ff ff ff ff ff ff ff ff |...f............|
   0070: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff |................|
   0080: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff |................|
   0090: ff ff ff ff ff ff ff ff ff ff ff ff ff ff f6 ed |................|
   00a0: ff ff ff ff ff ff fe 61 ff ff ff ff ff ff ff ff |.......a........|
   00b0: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff |................|
   00c0: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff |................|
   00d0: ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff |................|
   00e0: ff ff ff ff ff ff ff ff ff ff ff ff ff ff f1 02 |................|
   00f0: ff ff ff ff ff ff ed 1b ff ff ff ff ff ff ff ff |................|
 
 #endif
 
   $ hg debugnodemap --check
   revision in index:   5001
   revision in nodemap: 5001
 
 add a new commit
 
   $ hg up
   5001 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo foo > foo
   $ hg add foo
 
 
 Check slow-path config value handling
 -------------------------------------
 
 #if no-pure no-rust
 
   $ hg id --config "storage.revlog.persistent-nodemap.slow-path=invalid-value"
   unknown value for config "storage.revlog.persistent-nodemap.slow-path": "invalid-value"
   falling back to default value: abort
   abort: accessing `persistent-nodemap` repository without associated fast implementation.
   (check `hg help config.format.use-persistent-nodemap` for details)
   [255]
 
   $ hg log -r . --config "storage.revlog.persistent-nodemap.slow-path=warn"
   warning: accessing `persistent-nodemap` repository without associated fast implementation.
   (check `hg help config.format.use-persistent-nodemap` for details)
   changeset:   5000:6b02b8c7b966
   tag:         tip
   user:        debugbuilddag
   date:        Thu Jan 01 01:23:20 1970 +0000
   summary:     r5000
   
   $ hg ci -m 'foo' --config "storage.revlog.persistent-nodemap.slow-path=abort"
   abort: accessing `persistent-nodemap` repository without associated fast implementation.
   (check `hg help config.format.use-persistent-nodemap` for details)
   [255]
 
 #else
 
   $ hg id --config "storage.revlog.persistent-nodemap.slow-path=invalid-value"
   unknown value for config "storage.revlog.persistent-nodemap.slow-path": "invalid-value"
   falling back to default value: abort
   6b02b8c7b966+ tip
 
 #endif
 
   $ hg ci -m 'foo'
 
 #if no-pure no-rust
   $ hg debugnodemap --metadata
   uid: ???????????????? (glob)
   tip-rev: 5001
   tip-node: 16395c3cf7e231394735e6b1717823ada303fb0c
   data-length: 121088
   data-unused: 0
   data-unused: 0.000%
 #else
   $ hg debugnodemap --metadata
   uid: ???????????????? (glob)
   tip-rev: 5001
   tip-node: 16395c3cf7e231394735e6b1717823ada303fb0c
   data-length: 121344
   data-unused: 256
   data-unused: 0.211%
 #endif
 
   $ f --size .hg/store/00changelog.n
   .hg/store/00changelog.n: size=70
 
 (The pure code use the debug code that perform incremental update, the C code reencode from scratch)
 
 #if pure
   $ f --sha256 .hg/store/00changelog-*.nd --size
   .hg/store/00changelog-????????????????.nd: size=121344, sha256=cce54c5da5bde3ad72a4938673ed4064c86231b9c64376b082b163fdb20f8f66 (glob)
 #endif
 
 #if rust
   $ f --sha256 .hg/store/00changelog-*.nd --size
   .hg/store/00changelog-????????????????.nd: size=121344, sha256=952b042fcf614ceb37b542b1b723e04f18f83efe99bee4e0f5ccd232ef470e58 (glob)
 #endif
 
 #if no-pure no-rust
   $ f --sha256 .hg/store/00changelog-*.nd --size
   .hg/store/00changelog-????????????????.nd: size=121088, sha256=df7c06a035b96cb28c7287d349d603baef43240be7736fe34eea419a49702e17 (glob)
 #endif
 
   $ hg debugnodemap --check
   revision in index:   5002
   revision in nodemap: 5002
 
 Test code path without mmap
 ---------------------------
 
   $ echo bar > bar
   $ hg add bar
   $ hg ci -m 'bar' --config storage.revlog.persistent-nodemap.mmap=no
 
   $ hg debugnodemap --check --config storage.revlog.persistent-nodemap.mmap=yes
   revision in index:   5003
   revision in nodemap: 5003
   $ hg debugnodemap --check --config storage.revlog.persistent-nodemap.mmap=no
   revision in index:   5003
   revision in nodemap: 5003
 
 
 #if pure
   $ hg debugnodemap --metadata
   uid: ???????????????? (glob)
   tip-rev: 5002
   tip-node: 880b18d239dfa9f632413a2071bfdbcc4806a4fd
   data-length: 121600
   data-unused: 512
   data-unused: 0.421%
   $ f --sha256 .hg/store/00changelog-*.nd --size
   .hg/store/00changelog-????????????????.nd: size=121600, sha256=def52503d049ccb823974af313a98a935319ba61f40f3aa06a8be4d35c215054 (glob)
 #endif
 #if rust
   $ hg debugnodemap --metadata
   uid: ???????????????? (glob)
   tip-rev: 5002
   tip-node: 880b18d239dfa9f632413a2071bfdbcc4806a4fd
   data-length: 121600
   data-unused: 512
   data-unused: 0.421%
   $ f --sha256 .hg/store/00changelog-*.nd --size
   .hg/store/00changelog-????????????????.nd: size=121600, sha256=dacf5b5f1d4585fee7527d0e67cad5b1ba0930e6a0928f650f779aefb04ce3fb (glob)
 #endif
 #if no-pure no-rust
   $ hg debugnodemap --metadata
   uid: ???????????????? (glob)
   tip-rev: 5002
   tip-node: 880b18d239dfa9f632413a2071bfdbcc4806a4fd
   data-length: 121088
   data-unused: 0
   data-unused: 0.000%
   $ f --sha256 .hg/store/00changelog-*.nd --size
   .hg/store/00changelog-????????????????.nd: size=121088, sha256=59fcede3e3cc587755916ceed29e3c33748cd1aa7d2f91828ac83e7979d935e8 (glob)
 #endif
 
 Test force warming the cache
 
   $ rm .hg/store/00changelog.n
   $ hg debugnodemap --metadata
   $ hg debugupdatecache
 #if pure
   $ hg debugnodemap --metadata
   uid: ???????????????? (glob)
   tip-rev: 5002
   tip-node: 880b18d239dfa9f632413a2071bfdbcc4806a4fd
   data-length: 121088
   data-unused: 0
   data-unused: 0.000%
 #else
   $ hg debugnodemap --metadata
   uid: ???????????????? (glob)
   tip-rev: 5002
   tip-node: 880b18d239dfa9f632413a2071bfdbcc4806a4fd
   data-length: 121088
   data-unused: 0
   data-unused: 0.000%
 #endif
 
 Check out of sync nodemap
 =========================
 
 First copy old data on the side.
 
   $ mkdir ../tmp-copies
   $ cp .hg/store/00changelog-????????????????.nd .hg/store/00changelog.n ../tmp-copies
 
 Nodemap lagging behind
 ----------------------
 
 make a new commit
 
   $ echo bar2 > bar
   $ hg ci -m 'bar2'
   $ NODE=`hg log -r tip -T '{node}\n'`
   $ hg log -r "$NODE" -T '{rev}\n'
   5003
 
 If the nodemap is lagging behind, it can catch up fine
 
   $ hg debugnodemap --metadata
   uid: ???????????????? (glob)
   tip-rev: 5003
   tip-node: c9329770f979ade2d16912267c38ba5f82fd37b3
   data-length: 121344 (pure !)
   data-length: 121344 (rust !)
   data-length: 121152 (no-rust no-pure !)
   data-unused: 192 (pure !)
   data-unused: 192 (rust !)
   data-unused: 0 (no-rust no-pure !)
   data-unused: 0.158% (pure !)
   data-unused: 0.158% (rust !)
   data-unused: 0.000% (no-rust no-pure !)
   $ cp -f ../tmp-copies/* .hg/store/
   $ hg debugnodemap --metadata
   uid: ???????????????? (glob)
   tip-rev: 5002
   tip-node: 880b18d239dfa9f632413a2071bfdbcc4806a4fd
   data-length: 121088
   data-unused: 0
   data-unused: 0.000%
   $ hg log -r "$NODE" -T '{rev}\n'
   5003
 
 changelog altered
 -----------------
 
 If the nodemap is not gated behind a requirements, an unaware client can alter
 the repository so the revlog used to generate the nodemap is not longer
 compatible with the persistent nodemap. We need to detect that.
 
   $ hg up "$NODE~5"
   0 files updated, 0 files merged, 4 files removed, 0 files unresolved
   $ echo bar > babar
   $ hg add babar
   $ hg ci -m 'babar'
   created new head
   $ OTHERNODE=`hg log -r tip -T '{node}\n'`
   $ hg log -r "$OTHERNODE" -T '{rev}\n'
   5004
 
   $ hg --config extensions.strip= strip --rev "$NODE~1" --no-backup
 
 the nodemap should detect the changelog have been tampered with and recover.
 
   $ hg debugnodemap --metadata
   uid: ???????????????? (glob)
   tip-rev: 5002
   tip-node: b355ef8adce0949b8bdf6afc72ca853740d65944
   data-length: 121536 (pure !)
   data-length: 121088 (rust !)
   data-length: 121088 (no-pure no-rust !)
   data-unused: 448 (pure !)
   data-unused: 0 (rust !)
   data-unused: 0 (no-pure no-rust !)
   data-unused: 0.000% (rust !)
   data-unused: 0.369% (pure !)
   data-unused: 0.000% (no-pure no-rust !)
 
   $ cp -f ../tmp-copies/* .hg/store/
   $ hg debugnodemap --metadata
   uid: ???????????????? (glob)
   tip-rev: 5002
   tip-node: 880b18d239dfa9f632413a2071bfdbcc4806a4fd
   data-length: 121088
   data-unused: 0
   data-unused: 0.000%
   $ hg log -r "$OTHERNODE" -T '{rev}\n'
   5002
 
 missing data file
 -----------------
 
   $ UUID=`hg debugnodemap --metadata| grep 'uid:' | \
   > sed 's/uid: //'`
   $ FILE=.hg/store/00changelog-"${UUID}".nd
   $ mv $FILE ../tmp-data-file
   $ cp .hg/store/00changelog.n ../tmp-docket
 
 mercurial don't crash
 
   $ hg log -r .
   changeset:   5002:b355ef8adce0
   tag:         tip
   parent:      4998:d918ad6d18d3
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     babar
   
   $ hg debugnodemap --metadata
 
   $ hg debugupdatecache
   $ hg debugnodemap --metadata
   uid: * (glob)
   tip-rev: 5002
   tip-node: b355ef8adce0949b8bdf6afc72ca853740d65944
   data-length: 121088
   data-unused: 0
   data-unused: 0.000%
   $ mv ../tmp-data-file $FILE
   $ mv ../tmp-docket .hg/store/00changelog.n
 
 Check transaction related property
 ==================================
 
 An up to date nodemap should be available to shell hooks,
 
   $ echo dsljfl > a
   $ hg add a
   $ hg ci -m a
   $ hg debugnodemap --metadata
   uid: ???????????????? (glob)
   tip-rev: 5003
   tip-node: a52c5079765b5865d97b993b303a18740113bbb2
   data-length: 121088
   data-unused: 0
   data-unused: 0.000%
   $ echo babar2 > babar
   $ hg ci -m 'babar2' --config "hooks.pretxnclose.nodemap-test=hg debugnodemap --metadata"
   uid: ???????????????? (glob)
   tip-rev: 5004
   tip-node: 2f5fb1c06a16834c5679d672e90da7c5f3b1a984
   data-length: 121280 (pure !)
   data-length: 121280 (rust !)
   data-length: 121088 (no-pure no-rust !)
   data-unused: 192 (pure !)
   data-unused: 192 (rust !)
   data-unused: 0 (no-pure no-rust !)
   data-unused: 0.158% (pure !)
   data-unused: 0.158% (rust !)
   data-unused: 0.000% (no-pure no-rust !)
   $ hg debugnodemap --metadata
   uid: ???????????????? (glob)
   tip-rev: 5004
   tip-node: 2f5fb1c06a16834c5679d672e90da7c5f3b1a984
   data-length: 121280 (pure !)
   data-length: 121280 (rust !)
   data-length: 121088 (no-pure no-rust !)
   data-unused: 192 (pure !)
   data-unused: 192 (rust !)
   data-unused: 0 (no-pure no-rust !)
   data-unused: 0.158% (pure !)
   data-unused: 0.158% (rust !)
   data-unused: 0.000% (no-pure no-rust !)
 
 Another process does not see the pending nodemap content during run.
 
   $ PATH=$RUNTESTDIR/testlib/:$PATH
   $ echo qpoasp > a
   $ hg ci -m a2 \
   > --config "hooks.pretxnclose=wait-on-file 20 sync-repo-read sync-txn-pending" \
   > --config "hooks.txnclose=touch sync-txn-close" > output.txt 2>&1 &
 
 (read the repository while the commit transaction is pending)
 
   $ wait-on-file 20 sync-txn-pending && \
   > hg debugnodemap --metadata && \
   > wait-on-file 20 sync-txn-close sync-repo-read
   uid: ???????????????? (glob)
   tip-rev: 5004
   tip-node: 2f5fb1c06a16834c5679d672e90da7c5f3b1a984
   data-length: 121280 (pure !)
   data-length: 121280 (rust !)
   data-length: 121088 (no-pure no-rust !)
   data-unused: 192 (pure !)
   data-unused: 192 (rust !)
   data-unused: 0 (no-pure no-rust !)
   data-unused: 0.158% (pure !)
   data-unused: 0.158% (rust !)
   data-unused: 0.000% (no-pure no-rust !)
   $ hg debugnodemap --metadata
   uid: ???????????????? (glob)
   tip-rev: 5005
   tip-node: 90d5d3ba2fc47db50f712570487cb261a68c8ffe
   data-length: 121536 (pure !)
   data-length: 121536 (rust !)
   data-length: 121088 (no-pure no-rust !)
   data-unused: 448 (pure !)
   data-unused: 448 (rust !)
   data-unused: 0 (no-pure no-rust !)
   data-unused: 0.369% (pure !)
   data-unused: 0.369% (rust !)
   data-unused: 0.000% (no-pure no-rust !)
 
   $ cat output.txt
 
 Check that a failing transaction will properly revert the data
 
   $ echo plakfe > a
   $ f --size --sha256 .hg/store/00changelog-*.nd
   .hg/store/00changelog-????????????????.nd: size=121536, sha256=bb414468d225cf52d69132e1237afba34d4346ee2eb81b505027e6197b107f03 (glob) (pure !)
   .hg/store/00changelog-????????????????.nd: size=121536, sha256=909ac727bc4d1c0fda5f7bff3c620c98bd4a2967c143405a1503439e33b377da (glob) (rust !)
   .hg/store/00changelog-????????????????.nd: size=121088, sha256=342d36d30d86dde67d3cb6c002606c4a75bcad665595d941493845066d9c8ee0 (glob) (no-pure no-rust !)
   $ hg ci -m a3 --config "extensions.abort=$RUNTESTDIR/testlib/crash_transaction_late.py"
   transaction abort!
   rollback completed
   abort: This is a late abort
   [255]
   $ hg debugnodemap --metadata
   uid: ???????????????? (glob)
   tip-rev: 5005
   tip-node: 90d5d3ba2fc47db50f712570487cb261a68c8ffe
   data-length: 121536 (pure !)
   data-length: 121536 (rust !)
   data-length: 121088 (no-pure no-rust !)
   data-unused: 448 (pure !)
   data-unused: 448 (rust !)
   data-unused: 0 (no-pure no-rust !)
   data-unused: 0.369% (pure !)
   data-unused: 0.369% (rust !)
   data-unused: 0.000% (no-pure no-rust !)
   $ f --size --sha256 .hg/store/00changelog-*.nd
   .hg/store/00changelog-????????????????.nd: size=121536, sha256=bb414468d225cf52d69132e1237afba34d4346ee2eb81b505027e6197b107f03 (glob) (pure !)
   .hg/store/00changelog-????????????????.nd: size=121536, sha256=909ac727bc4d1c0fda5f7bff3c620c98bd4a2967c143405a1503439e33b377da (glob) (rust !)
   .hg/store/00changelog-????????????????.nd: size=121088, sha256=342d36d30d86dde67d3cb6c002606c4a75bcad665595d941493845066d9c8ee0 (glob) (no-pure no-rust !)
 
 Check that removing content does not confuse the nodemap
 --------------------------------------------------------
 
 removing data with rollback
 
   $ echo aso > a
   $ hg ci -m a4
   $ hg rollback
   repository tip rolled back to revision 5005 (undo commit)
   working directory now based on revision 5005
   $ hg id -r .
   90d5d3ba2fc4 tip
 
 roming data with strip
 
   $ echo aso > a
   $ hg ci -m a4
   $ hg --config extensions.strip= strip -r . --no-backup
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -r . --traceback
   90d5d3ba2fc4 tip
 
 Test upgrade / downgrade
 ========================
 
 downgrading
 
   $ cat << EOF >> .hg/hgrc
   > [format]
   > use-persistent-nodemap=no
   > EOF
   $ hg debugformat -v
   format-variant     repo config default
   fncache:            yes    yes     yes
   dotencode:          yes    yes     yes
   generaldelta:       yes    yes     yes
   share-safe:          no     no      no
   sparserevlog:       yes    yes     yes
   persistent-nodemap: yes     no      no
   copies-sdc:          no     no      no
   revlog-v2:           no     no      no
   plain-cl-delta:     yes    yes     yes
   compression:        zlib   zlib    zlib (no-zstd !)
   compression:        zstd   zstd    zstd (zstd !)
   compression-level:  default default default
   $ hg debugupgraderepo --run --no-backup
   upgrade will perform the following actions:
   
   requirements
      preserved: dotencode, fncache, generaldelta, revlogv1, sparserevlog, store (no-zstd !)
      preserved: dotencode, fncache, generaldelta, revlog-compression-zstd, revlogv1, sparserevlog, store (zstd !)
      removed: persistent-nodemap
   
   processed revlogs:
     - all-filelogs
     - changelog
     - manifest
   
   beginning upgrade...
   repository locked and read-only
   creating temporary repository to stage upgraded data: $TESTTMP/test-repo/.hg/upgrade.* (glob)
   (it is safe to interrupt this process any time before data migration completes)
   downgrading repository to not use persistent nodemap feature
   removing temporary repository $TESTTMP/test-repo/.hg/upgrade.* (glob)
   $ ls -1 .hg/store/ | egrep '00(changelog|manifest)(\.n|-.*\.nd)'
   00changelog-*.nd (glob)
   00manifest-*.nd (glob)
   undo.backup.00changelog.n
   undo.backup.00manifest.n
   $ hg debugnodemap --metadata
 
 
 upgrading
 
   $ cat << EOF >> .hg/hgrc
   > [format]
   > use-persistent-nodemap=yes
   > EOF
   $ hg debugformat -v
   format-variant     repo config default
   fncache:            yes    yes     yes
   dotencode:          yes    yes     yes
   generaldelta:       yes    yes     yes
   share-safe:          no     no      no
   sparserevlog:       yes    yes     yes
   persistent-nodemap:  no    yes      no
   copies-sdc:          no     no      no
   revlog-v2:           no     no      no
   plain-cl-delta:     yes    yes     yes
   compression:        zlib   zlib    zlib (no-zstd !)
   compression:        zstd   zstd    zstd (zstd !)
   compression-level:  default default default
   $ hg debugupgraderepo --run --no-backup
   upgrade will perform the following actions:
   
   requirements
      preserved: dotencode, fncache, generaldelta, revlogv1, sparserevlog, store (no-zstd !)
      preserved: dotencode, fncache, generaldelta, revlog-compression-zstd, revlogv1, sparserevlog, store (zstd !)
      added: persistent-nodemap
   
   persistent-nodemap
      Speedup revision lookup by node id.
   
   processed revlogs:
     - all-filelogs
     - changelog
     - manifest
   
   beginning upgrade...
   repository locked and read-only
   creating temporary repository to stage upgraded data: $TESTTMP/test-repo/.hg/upgrade.* (glob)
   (it is safe to interrupt this process any time before data migration completes)
   upgrading repository to use persistent nodemap feature
   removing temporary repository $TESTTMP/test-repo/.hg/upgrade.* (glob)
   $ ls -1 .hg/store/ | egrep '00(changelog|manifest)(\.n|-.*\.nd)'
   00changelog-*.nd (glob)
   00changelog.n
   00manifest-*.nd (glob)
   00manifest.n
   undo.backup.00changelog.n
   undo.backup.00manifest.n
 
   $ hg debugnodemap --metadata
   uid: * (glob)
   tip-rev: 5005
   tip-node: 90d5d3ba2fc47db50f712570487cb261a68c8ffe
   data-length: 121088
   data-unused: 0
   data-unused: 0.000%
 
 Running unrelated upgrade
 
   $ hg debugupgraderepo --run --no-backup --quiet --optimize re-delta-all
   upgrade will perform the following actions:
   
   requirements
      preserved: dotencode, fncache, generaldelta, persistent-nodemap, revlogv1, sparserevlog, store (no-zstd !)
      preserved: dotencode, fncache, generaldelta, persistent-nodemap, revlog-compression-zstd, revlogv1, sparserevlog, store (zstd !)
   
   optimisations: re-delta-all
   
   processed revlogs:
     - all-filelogs
     - changelog
     - manifest
   
   $ ls -1 .hg/store/ | egrep '00(changelog|manifest)(\.n|-.*\.nd)'
   00changelog-*.nd (glob)
   00changelog.n
   00manifest-*.nd (glob)
   00manifest.n
 
   $ hg debugnodemap --metadata
   uid: * (glob)
   tip-rev: 5005
   tip-node: 90d5d3ba2fc47db50f712570487cb261a68c8ffe
   data-length: 121088
   data-unused: 0
   data-unused: 0.000%
 
 Persistent nodemap and local/streaming clone
 ============================================
 
   $ cd ..
 
 standard clone
 --------------
 
 The persistent nodemap should exist after a streaming clone
 
   $ hg clone --pull --quiet -U test-repo standard-clone
   $ ls -1 standard-clone/.hg/store/ | egrep '00(changelog|manifest)(\.n|-.*\.nd)'
   00changelog-*.nd (glob)
   00changelog.n
   00manifest-*.nd (glob)
   00manifest.n
   $ hg -R standard-clone debugnodemap --metadata
   uid: * (glob)
   tip-rev: 5005
   tip-node: 90d5d3ba2fc47db50f712570487cb261a68c8ffe
   data-length: 121088
   data-unused: 0
   data-unused: 0.000%
 
 
 local clone
 ------------
 
 The persistent nodemap should exist after a streaming clone
 
   $ hg clone -U test-repo local-clone
   $ ls -1 local-clone/.hg/store/ | egrep '00(changelog|manifest)(\.n|-.*\.nd)'
   00changelog-*.nd (glob)
   00changelog.n
   00manifest-*.nd (glob)
   00manifest.n
   $ hg -R local-clone debugnodemap --metadata
   uid: * (glob)
   tip-rev: 5005
   tip-node: 90d5d3ba2fc47db50f712570487cb261a68c8ffe
   data-length: 121088
   data-unused: 0
   data-unused: 0.000%
 
 Test various corruption case
 ============================
 
 Missing datafile
 ----------------
 
 Test behavior with a missing datafile
 
   $ hg clone --quiet --pull test-repo corruption-test-repo
   $ ls -1 corruption-test-repo/.hg/store/00changelog*
   corruption-test-repo/.hg/store/00changelog-*.nd (glob)
   corruption-test-repo/.hg/store/00changelog.d
   corruption-test-repo/.hg/store/00changelog.i
   corruption-test-repo/.hg/store/00changelog.n
   $ rm corruption-test-repo/.hg/store/00changelog*.nd
   $ hg log -R corruption-test-repo -r .
   changeset:   5005:90d5d3ba2fc4
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a2
   
   $ ls -1 corruption-test-repo/.hg/store/00changelog*
   corruption-test-repo/.hg/store/00changelog.d
   corruption-test-repo/.hg/store/00changelog.i
   corruption-test-repo/.hg/store/00changelog.n
 
 Truncated data file
 -------------------
 
 Test behavior with a too short datafile
 
 rebuild the missing data
   $ hg -R corruption-test-repo debugupdatecache
   $ ls -1 corruption-test-repo/.hg/store/00changelog*
   corruption-test-repo/.hg/store/00changelog-*.nd (glob)
   corruption-test-repo/.hg/store/00changelog.d
   corruption-test-repo/.hg/store/00changelog.i
   corruption-test-repo/.hg/store/00changelog.n
 
 truncate the file
 
   $ datafilepath=`ls corruption-test-repo/.hg/store/00changelog*.nd`
   $ f -s $datafilepath
   corruption-test-repo/.hg/store/00changelog-*.nd: size=121088 (glob)
   $ dd if=$datafilepath bs=1000 count=10 of=$datafilepath-tmp status=none
   $ mv $datafilepath-tmp $datafilepath
   $ f -s $datafilepath
   corruption-test-repo/.hg/store/00changelog-*.nd: size=10000 (glob)
 
 Check that Mercurial reaction to this event
 
   $ hg -R corruption-test-repo log -r . --traceback
   changeset:   5005:90d5d3ba2fc4
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a2
   
 
 
 stream clone
 ============
 
 The persistent nodemap should exist after a streaming clone
 
 Simple case
 -----------
 
 No race condition
 
   $ hg clone -U --stream --config ui.ssh="\"$PYTHON\" \"$TESTDIR/dummyssh\"" ssh://user@dummy/test-repo stream-clone --debug | egrep '00(changelog|manifest)'
   adding [s] 00manifest.n (70 bytes)
   adding [s] 00manifest-*.nd (118 KB) (glob)
   adding [s] 00changelog.n (70 bytes)
   adding [s] 00changelog-*.nd (118 KB) (glob)
   adding [s] 00manifest.d (452 KB) (no-zstd !)
   adding [s] 00manifest.d (491 KB) (zstd !)
   adding [s] 00changelog.d (360 KB) (no-zstd !)
   adding [s] 00changelog.d (368 KB) (zstd !)
   adding [s] 00manifest.i (313 KB)
   adding [s] 00changelog.i (313 KB)
   $ ls -1 stream-clone/.hg/store/ | egrep '00(changelog|manifest)(\.n|-.*\.nd)'
   00changelog-*.nd (glob)
   00changelog.n
   00manifest-*.nd (glob)
   00manifest.n
   $ hg -R stream-clone debugnodemap --metadata
   uid: * (glob)
   tip-rev: 5005
   tip-node: 90d5d3ba2fc47db50f712570487cb261a68c8ffe
   data-length: 121088
   data-unused: 0
   data-unused: 0.000%
 
 new data appened
 -----------------
 
 Other commit happening on the server during the stream clone
 
 setup the step-by-step stream cloning
 
   $ HG_TEST_STREAM_WALKED_FILE_1="$TESTTMP/sync_file_walked_1"
   $ export HG_TEST_STREAM_WALKED_FILE_1
   $ HG_TEST_STREAM_WALKED_FILE_2="$TESTTMP/sync_file_walked_2"
   $ export HG_TEST_STREAM_WALKED_FILE_2
   $ HG_TEST_STREAM_WALKED_FILE_3="$TESTTMP/sync_file_walked_3"
   $ export HG_TEST_STREAM_WALKED_FILE_3
   $ cat << EOF >> test-repo/.hg/hgrc
   > [extensions]
   > steps=$RUNTESTDIR/testlib/ext-stream-clone-steps.py
   > EOF
 
 Check and record file state beforehand
 
   $ f --size test-repo/.hg/store/00changelog*
   test-repo/.hg/store/00changelog-*.nd: size=121088 (glob)
   test-repo/.hg/store/00changelog.d: size=376891 (zstd !)
   test-repo/.hg/store/00changelog.d: size=368890 (no-zstd !)
   test-repo/.hg/store/00changelog.i: size=320384
   test-repo/.hg/store/00changelog.n: size=70
   $ hg -R test-repo debugnodemap --metadata | tee server-metadata.txt
   uid: * (glob)
   tip-rev: 5005
   tip-node: 90d5d3ba2fc47db50f712570487cb261a68c8ffe
   data-length: 121088
   data-unused: 0
   data-unused: 0.000%
 
 Prepare a commit
 
   $ echo foo >> test-repo/foo
   $ hg -R test-repo/ add test-repo/foo
 
 Do a mix of clone and commit at the same time so that the file listed on disk differ at actual transfer time.
 
   $ (hg clone -U --stream --config ui.ssh="\"$PYTHON\" \"$TESTDIR/dummyssh\"" ssh://user@dummy/test-repo stream-clone-race-1 --debug 2>> clone-output | egrep '00(changelog|manifest)' >> clone-output; touch $HG_TEST_STREAM_WALKED_FILE_3) &
   $ $RUNTESTDIR/testlib/wait-on-file 10 $HG_TEST_STREAM_WALKED_FILE_1
   $ hg -R test-repo/ commit -m foo
   $ touch $HG_TEST_STREAM_WALKED_FILE_2
   $ $RUNTESTDIR/testlib/wait-on-file 10 $HG_TEST_STREAM_WALKED_FILE_3
   $ cat clone-output
   adding [s] 00manifest.n (70 bytes)
   adding [s] 00manifest-*.nd (118 KB) (glob)
   adding [s] 00changelog.n (70 bytes)
   adding [s] 00changelog-*.nd (118 KB) (glob)
   adding [s] 00manifest.d (452 KB) (no-zstd !)
   adding [s] 00manifest.d (491 KB) (zstd !)
   adding [s] 00changelog.d (360 KB) (no-zstd !)
   adding [s] 00changelog.d (368 KB) (zstd !)
   adding [s] 00manifest.i (313 KB)
   adding [s] 00changelog.i (313 KB)
 
 Check the result state
 
   $ f --size stream-clone-race-1/.hg/store/00changelog*
   stream-clone-race-1/.hg/store/00changelog-*.nd: size=121088 (glob)
   stream-clone-race-1/.hg/store/00changelog.d: size=368890 (no-zstd !)
   stream-clone-race-1/.hg/store/00changelog.d: size=376891 (zstd !)
   stream-clone-race-1/.hg/store/00changelog.i: size=320384
   stream-clone-race-1/.hg/store/00changelog.n: size=70
 
   $ hg -R stream-clone-race-1 debugnodemap --metadata | tee client-metadata.txt
   uid: * (glob)
   tip-rev: 5005
   tip-node: 90d5d3ba2fc47db50f712570487cb261a68c8ffe
   data-length: 121088
   data-unused: 0
   data-unused: 0.000%
 
 We get a usable nodemap, so no rewrite would be needed and the metadata should be identical
 (ie: the following diff should be empty)
 
 This isn't the case for the `no-rust` `no-pure` implementation as it use a very minimal nodemap implementation that unconditionnaly rewrite the nodemap "all the time".
 
 #if no-rust no-pure
   $ diff -u server-metadata.txt client-metadata.txt
   --- server-metadata.txt	* (glob)
   +++ client-metadata.txt	* (glob)
   @@ -1,4 +1,4 @@
   -uid: * (glob)
   +uid: * (glob)
    tip-rev: 5005
    tip-node: 90d5d3ba2fc47db50f712570487cb261a68c8ffe
    data-length: 121088
   [1]
 #else
   $ diff -u server-metadata.txt client-metadata.txt
 #endif
 
 
 Clean up after the test.
 
   $ rm -f "$HG_TEST_STREAM_WALKED_FILE_1"
   $ rm -f "$HG_TEST_STREAM_WALKED_FILE_2"
   $ rm -f "$HG_TEST_STREAM_WALKED_FILE_3"
 
 full regeneration
 -----------------
 
 A full nodemap is generated
 
 (ideally this test would append enough data to make sure the nodemap data file
 get changed, however to make thing simpler we will force the regeneration for
 this test.
 
 Check the initial state
 
   $ f --size test-repo/.hg/store/00changelog*
   test-repo/.hg/store/00changelog-*.nd: size=121344 (glob) (rust !)
   test-repo/.hg/store/00changelog-*.nd: size=121344 (glob) (pure !)
   test-repo/.hg/store/00changelog-*.nd: size=121152 (glob) (no-rust no-pure !)
   test-repo/.hg/store/00changelog.d: size=376950 (zstd !)
   test-repo/.hg/store/00changelog.d: size=368949 (no-zstd !)
   test-repo/.hg/store/00changelog.i: size=320448
   test-repo/.hg/store/00changelog.n: size=70
   $ hg -R test-repo debugnodemap --metadata | tee server-metadata-2.txt
   uid: * (glob)
   tip-rev: 5006
   tip-node: ed2ec1eef9aa2a0ec5057c51483bc148d03e810b
   data-length: 121344 (rust !)
   data-length: 121344 (pure !)
   data-length: 121152 (no-rust no-pure !)
   data-unused: 192 (rust !)
   data-unused: 192 (pure !)
   data-unused: 0 (no-rust no-pure !)
   data-unused: 0.158% (rust !)
   data-unused: 0.158% (pure !)
   data-unused: 0.000% (no-rust no-pure !)
 
 Performe the mix of clone and full refresh of the nodemap, so that the files
 (and filenames) are different between listing time and actual transfer time.
 
   $ (hg clone -U --stream --config ui.ssh="\"$PYTHON\" \"$TESTDIR/dummyssh\"" ssh://user@dummy/test-repo stream-clone-race-2 --debug 2>> clone-output-2 | egrep '00(changelog|manifest)' >> clone-output-2; touch $HG_TEST_STREAM_WALKED_FILE_3) &
   $ $RUNTESTDIR/testlib/wait-on-file 10 $HG_TEST_STREAM_WALKED_FILE_1
   $ rm test-repo/.hg/store/00changelog.n
   $ rm test-repo/.hg/store/00changelog-*.nd
   $ hg -R test-repo/ debugupdatecache
   $ touch $HG_TEST_STREAM_WALKED_FILE_2
   $ $RUNTESTDIR/testlib/wait-on-file 10 $HG_TEST_STREAM_WALKED_FILE_3
   $ cat clone-output-2
-  adding [s] undo.backup.00manifest.n (70 bytes) (known-bad-output !)
-  adding [s] undo.backup.00changelog.n (70 bytes) (known-bad-output !)
   adding [s] 00manifest.n (70 bytes)
   adding [s] 00manifest-*.nd (118 KB) (glob)
   adding [s] 00changelog.n (70 bytes)
   adding [s] 00changelog-*.nd (118 KB) (glob)
   adding [s] 00manifest.d (492 KB) (zstd !)
   adding [s] 00manifest.d (452 KB) (no-zstd !)
   adding [s] 00changelog.d (360 KB) (no-zstd !)
   adding [s] 00changelog.d (368 KB) (zstd !)
   adding [s] 00manifest.i (313 KB)
   adding [s] 00changelog.i (313 KB)
 
 Check the result.
 
   $ f --size stream-clone-race-2/.hg/store/00changelog*
   stream-clone-race-2/.hg/store/00changelog-*.nd: size=121344 (glob) (rust !)
   stream-clone-race-2/.hg/store/00changelog-*.nd: size=121344 (glob) (pure !)
   stream-clone-race-2/.hg/store/00changelog-*.nd: size=121152 (glob) (no-rust no-pure !)
   stream-clone-race-2/.hg/store/00changelog.d: size=376950 (zstd !)
   stream-clone-race-2/.hg/store/00changelog.d: size=368949 (no-zstd !)
   stream-clone-race-2/.hg/store/00changelog.i: size=320448
   stream-clone-race-2/.hg/store/00changelog.n: size=70
 
   $ hg -R stream-clone-race-2 debugnodemap --metadata | tee client-metadata-2.txt
   uid: * (glob)
   tip-rev: 5006
   tip-node: ed2ec1eef9aa2a0ec5057c51483bc148d03e810b
   data-length: 121344 (rust !)
   data-unused: 192 (rust !)
   data-unused: 0.158% (rust !)
   data-length: 121152 (no-rust no-pure !)
   data-unused: 0 (no-rust no-pure !)
   data-unused: 0.000% (no-rust no-pure !)
   data-length: 121344 (pure !)
   data-unused: 192 (pure !)
   data-unused: 0.158% (pure !)
 
 We get a usable nodemap, so no rewrite would be needed and the metadata should be identical
 (ie: the following diff should be empty)
 
 This isn't the case for the `no-rust` `no-pure` implementation as it use a very minimal nodemap implementation that unconditionnaly rewrite the nodemap "all the time".
 
 #if no-rust no-pure
   $ diff -u server-metadata-2.txt client-metadata-2.txt
   --- server-metadata-2.txt	* (glob)
   +++ client-metadata-2.txt	* (glob)
   @@ -1,4 +1,4 @@
   -uid: * (glob)
   +uid: * (glob)
    tip-rev: 5006
    tip-node: ed2ec1eef9aa2a0ec5057c51483bc148d03e810b
    data-length: 121152
   [1]
 #else
   $ diff -u server-metadata-2.txt client-metadata-2.txt
 #endif
 
 Clean up after the test
 
   $ rm -f $HG_TEST_STREAM_WALKED_FILE_1
   $ rm -f $HG_TEST_STREAM_WALKED_FILE_2
   $ rm -f $HG_TEST_STREAM_WALKED_FILE_3