store: issue a single entry for each revlog

We now yield a single entry, with data about each files involved. This help to
simplify multiple code using this and it will help to further simplify and
fixes the streaming code.

mercurial/repair.py

@@ -1,576 +1,574
 # repair.py - functions for repository repair for mercurial
 #
 # Copyright 2005, 2006 Chris Mason <[e-mail]>
 # Copyright 2007 Olivia Mackall
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 from .i18n import _
 from .node import (
     hex,
     short,
 )
 from . import (
     bundle2,
     changegroup,
     discovery,
     error,
     exchange,
     obsolete,
     obsutil,
     pathutil,
     phases,
     requirements,
     scmutil,
     store,
     transaction,
     util,
 )
 from .utils import (
     hashutil,
     urlutil,
 )
 
 
 def backupbundle(
     repo,
     bases,
     heads,
     node,
     suffix,
     compress=True,
     obsolescence=True,
     tmp_backup=False,
 ):
     """create a bundle with the specified revisions as a backup"""
 
     backupdir = b"strip-backup"
     vfs = repo.vfs
     if not vfs.isdir(backupdir):
         vfs.mkdir(backupdir)
 
     # Include a hash of all the nodes in the filename for uniqueness
     allcommits = repo.set(b'%ln::%ln', bases, heads)
     allhashes = sorted(c.hex() for c in allcommits)
     totalhash = hashutil.sha1(b''.join(allhashes)).digest()
     name = b"%s/%s-%s-%s.hg" % (
         backupdir,
         short(node),
         hex(totalhash[:4]),
         suffix,
     )
 
     cgversion = changegroup.localversion(repo)
     comp = None
     if cgversion != b'01':
         bundletype = b"HG20"
         if compress:
             comp = b'BZ'
     elif compress:
         bundletype = b"HG10BZ"
     else:
         bundletype = b"HG10UN"
 
     outgoing = discovery.outgoing(repo, missingroots=bases, ancestorsof=heads)
     contentopts = {
         b'cg.version': cgversion,
         b'obsolescence': obsolescence,
         b'phases': True,
     }
     return bundle2.writenewbundle(
         repo.ui,
         repo,
         b'strip',
         name,
         bundletype,
         outgoing,
         contentopts,
         vfs,
         compression=comp,
         allow_internal=tmp_backup,
     )
 
 
 def _collectfiles(repo, striprev):
     """find out the filelogs affected by the strip"""
     files = set()
 
     for x in range(striprev, len(repo)):
         files.update(repo[x].files())
 
     return sorted(files)
 
 
 def _collectrevlog(revlog, striprev):
     _, brokenset = revlog.getstrippoint(striprev)
     return [revlog.linkrev(r) for r in brokenset]
 
 
 def _collectbrokencsets(repo, files, striprev):
     """return the changesets which will be broken by the truncation"""
     s = set()
 
     for revlog in manifestrevlogs(repo):
         s.update(_collectrevlog(revlog, striprev))
     for fname in files:
         s.update(_collectrevlog(repo.file(fname), striprev))
 
     return s
 
 
 def strip(ui, repo, nodelist, backup=True, topic=b'backup'):
     # This function requires the caller to lock the repo, but it operates
     # within a transaction of its own, and thus requires there to be no current
     # transaction when it is called.
     if repo.currenttransaction() is not None:
         raise error.ProgrammingError(b'cannot strip from inside a transaction')
 
     # Simple way to maintain backwards compatibility for this
     # argument.
     if backup in [b'none', b'strip']:
         backup = False
 
     repo = repo.unfiltered()
     repo.destroying()
     vfs = repo.vfs
     # load bookmark before changelog to avoid side effect from outdated
     # changelog (see repo._refreshchangelog)
     repo._bookmarks
     cl = repo.changelog
 
     # TODO handle undo of merge sets
     if isinstance(nodelist, bytes):
         nodelist = [nodelist]
     striplist = [cl.rev(node) for node in nodelist]
     striprev = min(striplist)
 
     files = _collectfiles(repo, striprev)
     saverevs = _collectbrokencsets(repo, files, striprev)
 
     # Some revisions with rev > striprev may not be descendants of striprev.
     # We have to find these revisions and put them in a bundle, so that
     # we can restore them after the truncations.
     # To create the bundle we use repo.changegroupsubset which requires
     # the list of heads and bases of the set of interesting revisions.
     # (head = revision in the set that has no descendant in the set;
     #  base = revision in the set that has no ancestor in the set)
     tostrip = set(striplist)
     saveheads = set(saverevs)
     for r in cl.revs(start=striprev + 1):
         if any(p in tostrip for p in cl.parentrevs(r)):
             tostrip.add(r)
 
         if r not in tostrip:
             saverevs.add(r)
             saveheads.difference_update(cl.parentrevs(r))
             saveheads.add(r)
     saveheads = [cl.node(r) for r in saveheads]
 
     # compute base nodes
     if saverevs:
         descendants = set(cl.descendants(saverevs))
         saverevs.difference_update(descendants)
     savebases = [cl.node(r) for r in saverevs]
     stripbases = [cl.node(r) for r in tostrip]
 
     stripobsidx = obsmarkers = ()
     if repo.ui.configbool(b'devel', b'strip-obsmarkers'):
         obsmarkers = obsutil.exclusivemarkers(repo, stripbases)
     if obsmarkers:
         stripobsidx = [
             i for i, m in enumerate(repo.obsstore) if m in obsmarkers
         ]
 
     newbmtarget, updatebm = _bookmarkmovements(repo, tostrip)
 
     backupfile = None
     node = nodelist[-1]
     if backup:
         backupfile = _createstripbackup(repo, stripbases, node, topic)
     # create a changegroup for all the branches we need to keep
     tmpbundlefile = None
     if saveheads:
         # do not compress temporary bundle if we remove it from disk later
         #
         # We do not include obsolescence, it might re-introduce prune markers
         # we are trying to strip.  This is harmless since the stripped markers
         # are already backed up and we did not touched the markers for the
         # saved changesets.
         tmpbundlefile = backupbundle(
             repo,
             savebases,
             saveheads,
             node,
             b'temp',
             compress=False,
             obsolescence=False,
             tmp_backup=True,
         )
 
     with ui.uninterruptible():
         try:
             with repo.transaction(b"strip") as tr:
                 # TODO this code violates the interface abstraction of the
                 # transaction and makes assumptions that file storage is
                 # using append-only files. We'll need some kind of storage
                 # API to handle stripping for us.
                 oldfiles = set(tr._offsetmap.keys())
                 oldfiles.update(tr._newfiles)
 
                 tr.startgroup()
                 cl.strip(striprev, tr)
                 stripmanifest(repo, striprev, tr, files)
 
                 for fn in files:
                     repo.file(fn).strip(striprev, tr)
                 tr.endgroup()
 
                 entries = tr.readjournal()
 
                 for file, troffset in entries:
                     if file in oldfiles:
                         continue
                     with repo.svfs(file, b'a', checkambig=True) as fp:
                         fp.truncate(troffset)
                     if troffset == 0:
                         repo.store.markremoved(file)
 
                 deleteobsmarkers(repo.obsstore, stripobsidx)
                 del repo.obsstore
                 repo.invalidatevolatilesets()
                 repo._phasecache.filterunknown(repo)
 
             if tmpbundlefile:
                 ui.note(_(b"adding branch\n"))
                 f = vfs.open(tmpbundlefile, b"rb")
                 gen = exchange.readbundle(ui, f, tmpbundlefile, vfs)
                 # silence internal shuffling chatter
                 maybe_silent = (
                     repo.ui.silent()
                     if not repo.ui.verbose
                     else util.nullcontextmanager()
                 )
                 with maybe_silent:
                     tmpbundleurl = b'bundle:' + vfs.join(tmpbundlefile)
                     txnname = b'strip'
                     if not isinstance(gen, bundle2.unbundle20):
                         txnname = b"strip\n%s" % urlutil.hidepassword(
                             tmpbundleurl
                         )
                     with repo.transaction(txnname) as tr:
                         bundle2.applybundle(
                             repo, gen, tr, source=b'strip', url=tmpbundleurl
                         )
                 f.close()
 
             with repo.transaction(b'repair') as tr:
                 bmchanges = [(m, repo[newbmtarget].node()) for m in updatebm]
                 repo._bookmarks.applychanges(repo, tr, bmchanges)
 
             transaction.cleanup_undo_files(repo.ui.warn, repo.vfs_map)
 
         except:  # re-raises
             if backupfile:
                 ui.warn(
                     _(b"strip failed, backup bundle stored in '%s'\n")
                     % vfs.join(backupfile)
                 )
             if tmpbundlefile:
                 ui.warn(
                     _(b"strip failed, unrecovered changes stored in '%s'\n")
                     % vfs.join(tmpbundlefile)
                 )
                 ui.warn(
                     _(
                         b"(fix the problem, then recover the changesets with "
                         b"\"hg unbundle '%s'\")\n"
                     )
                     % vfs.join(tmpbundlefile)
                 )
             raise
         else:
             if tmpbundlefile:
                 # Remove temporary bundle only if there were no exceptions
                 vfs.unlink(tmpbundlefile)
 
     repo.destroyed()
     # return the backup file path (or None if 'backup' was False) so
     # extensions can use it
     return backupfile
 
 
 def softstrip(ui, repo, nodelist, backup=True, topic=b'backup'):
     """perform a "soft" strip using the archived phase"""
     tostrip = [c.node() for c in repo.set(b'sort(%ln::)', nodelist)]
     if not tostrip:
         return None
 
     backupfile = None
     if backup:
         node = tostrip[0]
         backupfile = _createstripbackup(repo, tostrip, node, topic)
 
     newbmtarget, updatebm = _bookmarkmovements(repo, tostrip)
     with repo.transaction(b'strip') as tr:
         phases.retractboundary(repo, tr, phases.archived, tostrip)
         bmchanges = [(m, repo[newbmtarget].node()) for m in updatebm]
         repo._bookmarks.applychanges(repo, tr, bmchanges)
     return backupfile
 
 
 def _bookmarkmovements(repo, tostrip):
     # compute necessary bookmark movement
     bm = repo._bookmarks
     updatebm = []
     for m in bm:
         rev = repo[bm[m]].rev()
         if rev in tostrip:
             updatebm.append(m)
     newbmtarget = None
     # If we need to move bookmarks, compute bookmark
     # targets. Otherwise we can skip doing this logic.
     if updatebm:
         # For a set s, max(parents(s) - s) is the same as max(heads(::s - s)),
         # but is much faster
         newbmtarget = repo.revs(b'max(parents(%ld) - (%ld))', tostrip, tostrip)
         if newbmtarget:
             newbmtarget = repo[newbmtarget.first()].node()
         else:
             newbmtarget = b'.'
     return newbmtarget, updatebm
 
 
 def _createstripbackup(repo, stripbases, node, topic):
     # backup the changeset we are about to strip
     vfs = repo.vfs
     unfi = repo.unfiltered()
     to_node = unfi.changelog.node
     # internal changeset are internal implementation details that should not
     # leave the repository and not be exposed to the users. In addition feature
     # using them requires to be resistant to strip. See test case for more
     # details.
     all_backup = unfi.revs(
         b"(%ln)::(%ld) and not _internal()",
         stripbases,
         unfi.changelog.headrevs(),
     )
     if not all_backup:
         return None
 
     def to_nodes(revs):
         return [to_node(r) for r in revs]
 
     bases = to_nodes(unfi.revs("roots(%ld)", all_backup))
     heads = to_nodes(unfi.revs("heads(%ld)", all_backup))
     backupfile = backupbundle(repo, bases, heads, node, topic)
     repo.ui.status(_(b"saved backup bundle to %s\n") % vfs.join(backupfile))
     repo.ui.log(
         b"backupbundle", b"saved backup bundle to %s\n", vfs.join(backupfile)
     )
     return backupfile
 
 
 def safestriproots(ui, repo, nodes):
     """return list of roots of nodes where descendants are covered by nodes"""
     torev = repo.unfiltered().changelog.rev
     revs = {torev(n) for n in nodes}
     # tostrip = wanted - unsafe = wanted - ancestors(orphaned)
     # orphaned = affected - wanted
     # affected = descendants(roots(wanted))
     # wanted = revs
     revset = b'%ld - ( ::( (roots(%ld):: and not _phase(%s)) -%ld) )'
     tostrip = set(repo.revs(revset, revs, revs, phases.internal, revs))
     notstrip = revs - tostrip
     if notstrip:
         nodestr = b', '.join(sorted(short(repo[n].node()) for n in notstrip))
         ui.warn(
             _(b'warning: orphaned descendants detected, not stripping %s\n')
             % nodestr
         )
     return [c.node() for c in repo.set(b'roots(%ld)', tostrip)]
 
 
 class stripcallback:
     """used as a transaction postclose callback"""
 
     def __init__(self, ui, repo, backup, topic):
         self.ui = ui
         self.repo = repo
         self.backup = backup
         self.topic = topic or b'backup'
         self.nodelist = []
 
     def addnodes(self, nodes):
         self.nodelist.extend(nodes)
 
     def __call__(self, tr):
         roots = safestriproots(self.ui, self.repo, self.nodelist)
         if roots:
             strip(self.ui, self.repo, roots, self.backup, self.topic)
 
 
 def delayedstrip(ui, repo, nodelist, topic=None, backup=True):
     """like strip, but works inside transaction and won't strip irreverent revs
 
     nodelist must explicitly contain all descendants. Otherwise a warning will
     be printed that some nodes are not stripped.
 
     Will do a backup if `backup` is True. The last non-None "topic" will be
     used as the backup topic name. The default backup topic name is "backup".
     """
     tr = repo.currenttransaction()
     if not tr:
         nodes = safestriproots(ui, repo, nodelist)
         return strip(ui, repo, nodes, backup=backup, topic=topic)
     # transaction postclose callbacks are called in alphabet order.
     # use '\xff' as prefix so we are likely to be called last.
     callback = tr.getpostclose(b'\xffstrip')
     if callback is None:
         callback = stripcallback(ui, repo, backup=backup, topic=topic)
         tr.addpostclose(b'\xffstrip', callback)
     if topic:
         callback.topic = topic
     callback.addnodes(nodelist)
 
 
 def stripmanifest(repo, striprev, tr, files):
     for revlog in manifestrevlogs(repo):
         revlog.strip(striprev, tr)
 
 
 def manifestrevlogs(repo):
     yield repo.manifestlog.getstorage(b'')
     if scmutil.istreemanifest(repo):
         # This logic is safe if treemanifest isn't enabled, but also
         # pointless, so we skip it if treemanifest isn't enabled.
         for entry in repo.store.datafiles():
             if not entry.is_revlog:
                 continue
-            if not entry.revlog_type == store.FILEFLAGS_MANIFESTLOG:
-                continue
-            if entry.is_revlog_main:
+            if entry.revlog_type == store.FILEFLAGS_MANIFESTLOG:
                 yield repo.manifestlog.getstorage(entry.target_id)
 
 
 def rebuildfncache(ui, repo, only_data=False):
     """Rebuilds the fncache file from repo history.
 
     Missing entries will be added. Extra entries will be removed.
     """
     repo = repo.unfiltered()
 
     if requirements.FNCACHE_REQUIREMENT not in repo.requirements:
         ui.warn(
             _(
                 b'(not rebuilding fncache because repository does not '
                 b'support fncache)\n'
             )
         )
         return
 
     with repo.lock():
         fnc = repo.store.fncache
         fnc.ensureloaded(warn=ui.warn)
 
         oldentries = set(fnc.entries)
         newentries = set()
         seenfiles = set()
 
         if only_data:
             # Trust the listing of .i from the fncache, but not the .d. This is
             # much faster, because we only need to stat every possible .d files,
             # instead of reading the full changelog
             for f in fnc:
                 if f[:5] == b'data/' and f[-2:] == b'.i':
                     seenfiles.add(f[5:-2])
                     newentries.add(f)
                     dataf = f[:-2] + b'.d'
                     if repo.store._exists(dataf):
                         newentries.add(dataf)
         else:
             progress = ui.makeprogress(
                 _(b'rebuilding'), unit=_(b'changesets'), total=len(repo)
             )
             for rev in repo:
                 progress.update(rev)
 
                 ctx = repo[rev]
                 for f in ctx.files():
                     # This is to minimize I/O.
                     if f in seenfiles:
                         continue
                     seenfiles.add(f)
 
                     i = b'data/%s.i' % f
                     d = b'data/%s.d' % f
 
                     if repo.store._exists(i):
                         newentries.add(i)
                     if repo.store._exists(d):
                         newentries.add(d)
 
             progress.complete()
 
         if requirements.TREEMANIFEST_REQUIREMENT in repo.requirements:
             # This logic is safe if treemanifest isn't enabled, but also
             # pointless, so we skip it if treemanifest isn't enabled.
             for dir in pathutil.dirs(seenfiles):
                 i = b'meta/%s/00manifest.i' % dir
                 d = b'meta/%s/00manifest.d' % dir
 
                 if repo.store._exists(i):
                     newentries.add(i)
                 if repo.store._exists(d):
                     newentries.add(d)
 
         addcount = len(newentries - oldentries)
         removecount = len(oldentries - newentries)
         for p in sorted(oldentries - newentries):
             ui.write(_(b'removing %s\n') % p)
         for p in sorted(newentries - oldentries):
             ui.write(_(b'adding %s\n') % p)
 
         if addcount or removecount:
             ui.write(
                 _(b'%d items added, %d removed from fncache\n')
                 % (addcount, removecount)
             )
             fnc.entries = newentries
             fnc._dirty = True
 
             with repo.transaction(b'fncache') as tr:
                 fnc.write(tr)
         else:
             ui.write(_(b'fncache already up to date\n'))
 
 
 def deleteobsmarkers(obsstore, indices):
     """Delete some obsmarkers from obsstore and return how many were deleted
 
     'indices' is a list of ints which are the indices
     of the markers to be deleted.
 
     Every invocation of this function completely rewrites the obsstore file,
     skipping the markers we want to be removed. The new temporary file is
     created, remaining markers are written there and on .close() this file
     gets atomically renamed to obsstore, thus guaranteeing consistency."""
     if not indices:
         # we don't want to rewrite the obsstore with the same content
         return
 
     left = []
     current = obsstore._all
     n = 0
     for i, m in enumerate(current):
         if i in indices:
             n += 1
             continue
         left.append(m)
 
     newobsstorefile = obsstore.svfs(b'obsstore', b'w', atomictemp=True)
     for bytes in obsolete.encodemarkers(left, True, obsstore._version):
         newobsstorefile.write(bytes)
     newobsstorefile.close()
     return n

mercurial/revlogutils/rewrite.py

@@ -1,887 +1,885
 # censor code related to censoring revision
 # coding: utf8
 #
 # Copyright 2021 Pierre-Yves David <[e-mail]>
 # Copyright 2015 Google, Inc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 import binascii
 import contextlib
 import os
 import struct
 
 from ..node import (
     nullrev,
 )
 from .constants import (
     COMP_MODE_PLAIN,
     ENTRY_DATA_COMPRESSED_LENGTH,
     ENTRY_DATA_COMPRESSION_MODE,
     ENTRY_DATA_OFFSET,
     ENTRY_DATA_UNCOMPRESSED_LENGTH,
     ENTRY_DELTA_BASE,
     ENTRY_LINK_REV,
     ENTRY_NODE_ID,
     ENTRY_PARENT_1,
     ENTRY_PARENT_2,
     ENTRY_SIDEDATA_COMPRESSED_LENGTH,
     ENTRY_SIDEDATA_COMPRESSION_MODE,
     ENTRY_SIDEDATA_OFFSET,
     REVIDX_ISCENSORED,
     REVLOGV0,
     REVLOGV1,
 )
 from ..i18n import _
 
 from .. import (
     error,
     mdiff,
     pycompat,
     revlogutils,
     util,
 )
 from ..utils import (
     storageutil,
 )
 from . import (
     constants,
     deltas,
 )
 
 
 def v1_censor(rl, tr, censornode, tombstone=b''):
     """censors a revision in a "version 1" revlog"""
     assert rl._format_version == constants.REVLOGV1, rl._format_version
 
     # avoid cycle
     from .. import revlog
 
     censorrev = rl.rev(censornode)
     tombstone = storageutil.packmeta({b'censored': tombstone}, b'')
 
     # Rewriting the revlog in place is hard. Our strategy for censoring is
     # to create a new revlog, copy all revisions to it, then replace the
     # revlogs on transaction close.
     #
     # This is a bit dangerous. We could easily have a mismatch of state.
     newrl = revlog.revlog(
         rl.opener,
         target=rl.target,
         radix=rl.radix,
         postfix=b'tmpcensored',
         censorable=True,
     )
     newrl._format_version = rl._format_version
     newrl._format_flags = rl._format_flags
     newrl._generaldelta = rl._generaldelta
     newrl._parse_index = rl._parse_index
 
     for rev in rl.revs():
         node = rl.node(rev)
         p1, p2 = rl.parents(node)
 
         if rev == censorrev:
             newrl.addrawrevision(
                 tombstone,
                 tr,
                 rl.linkrev(censorrev),
                 p1,
                 p2,
                 censornode,
                 constants.REVIDX_ISCENSORED,
             )
 
             if newrl.deltaparent(rev) != nullrev:
                 m = _(b'censored revision stored as delta; cannot censor')
                 h = _(
                     b'censoring of revlogs is not fully implemented;'
                     b' please report this bug'
                 )
                 raise error.Abort(m, hint=h)
             continue
 
         if rl.iscensored(rev):
             if rl.deltaparent(rev) != nullrev:
                 m = _(
                     b'cannot censor due to censored '
                     b'revision having delta stored'
                 )
                 raise error.Abort(m)
             rawtext = rl._chunk(rev)
         else:
             rawtext = rl.rawdata(rev)
 
         newrl.addrawrevision(
             rawtext, tr, rl.linkrev(rev), p1, p2, node, rl.flags(rev)
         )
 
     tr.addbackup(rl._indexfile, location=b'store')
     if not rl._inline:
         tr.addbackup(rl._datafile, location=b'store')
 
     rl.opener.rename(newrl._indexfile, rl._indexfile)
     if not rl._inline:
         rl.opener.rename(newrl._datafile, rl._datafile)
 
     rl.clearcaches()
     rl._loadindex()
 
 
 def v2_censor(revlog, tr, censornode, tombstone=b''):
     """censors a revision in a "version 2" revlog"""
     assert revlog._format_version != REVLOGV0, revlog._format_version
     assert revlog._format_version != REVLOGV1, revlog._format_version
 
     censor_revs = {revlog.rev(censornode)}
     _rewrite_v2(revlog, tr, censor_revs, tombstone)
 
 
 def _rewrite_v2(revlog, tr, censor_revs, tombstone=b''):
     """rewrite a revlog to censor some of its content
 
     General principle
 
     We create new revlog files (index/data/sidedata) to copy the content of
     the existing data without the censored data.
 
     We need to recompute new delta for any revision that used the censored
     revision as delta base. As the cumulative size of the new delta may be
     large, we store them in a temporary file until they are stored in their
     final destination.
 
     All data before the censored data can be blindly copied. The rest needs
     to be copied as we go and the associated index entry needs adjustement.
     """
     assert revlog._format_version != REVLOGV0, revlog._format_version
     assert revlog._format_version != REVLOGV1, revlog._format_version
 
     old_index = revlog.index
     docket = revlog._docket
 
     tombstone = storageutil.packmeta({b'censored': tombstone}, b'')
 
     first_excl_rev = min(censor_revs)
 
     first_excl_entry = revlog.index[first_excl_rev]
     index_cutoff = revlog.index.entry_size * first_excl_rev
     data_cutoff = first_excl_entry[ENTRY_DATA_OFFSET] >> 16
     sidedata_cutoff = revlog.sidedata_cut_off(first_excl_rev)
 
     with pycompat.unnamedtempfile(mode=b"w+b") as tmp_storage:
         # rev → (new_base, data_start, data_end, compression_mode)
         rewritten_entries = _precompute_rewritten_delta(
             revlog,
             old_index,
             censor_revs,
             tmp_storage,
         )
 
         all_files = _setup_new_files(
             revlog,
             index_cutoff,
             data_cutoff,
             sidedata_cutoff,
         )
 
         # we dont need to open the old index file since its content already
         # exist in a usable form in `old_index`.
         with all_files() as open_files:
             (
                 old_data_file,
                 old_sidedata_file,
                 new_index_file,
                 new_data_file,
                 new_sidedata_file,
             ) = open_files
 
             # writing the censored revision
 
             # Writing all subsequent revisions
             for rev in range(first_excl_rev, len(old_index)):
                 if rev in censor_revs:
                     _rewrite_censor(
                         revlog,
                         old_index,
                         open_files,
                         rev,
                         tombstone,
                     )
                 else:
                     _rewrite_simple(
                         revlog,
                         old_index,
                         open_files,
                         rev,
                         rewritten_entries,
                         tmp_storage,
                     )
     docket.write(transaction=None, stripping=True)
 
 
 def _precompute_rewritten_delta(
     revlog,
     old_index,
     excluded_revs,
     tmp_storage,
 ):
     """Compute new delta for revisions whose delta is based on revision that
     will not survive as is.
 
     Return a mapping: {rev → (new_base, data_start, data_end, compression_mode)}
     """
     dc = deltas.deltacomputer(revlog)
     rewritten_entries = {}
     first_excl_rev = min(excluded_revs)
     with revlog._segmentfile._open_read() as dfh:
         for rev in range(first_excl_rev, len(old_index)):
             if rev in excluded_revs:
                 # this revision will be preserved as is, so we don't need to
                 # consider recomputing a delta.
                 continue
             entry = old_index[rev]
             if entry[ENTRY_DELTA_BASE] not in excluded_revs:
                 continue
             # This is a revision that use the censored revision as the base
             # for its delta. We need a need new deltas
             if entry[ENTRY_DATA_UNCOMPRESSED_LENGTH] == 0:
                 # this revision is empty, we can delta against nullrev
                 rewritten_entries[rev] = (nullrev, 0, 0, COMP_MODE_PLAIN)
             else:
 
                 text = revlog.rawdata(rev, _df=dfh)
                 info = revlogutils.revisioninfo(
                     node=entry[ENTRY_NODE_ID],
                     p1=revlog.node(entry[ENTRY_PARENT_1]),
                     p2=revlog.node(entry[ENTRY_PARENT_2]),
                     btext=[text],
                     textlen=len(text),
                     cachedelta=None,
                     flags=entry[ENTRY_DATA_OFFSET] & 0xFFFF,
                 )
                 d = dc.finddeltainfo(
                     info, dfh, excluded_bases=excluded_revs, target_rev=rev
                 )
                 default_comp = revlog._docket.default_compression_header
                 comp_mode, d = deltas.delta_compression(default_comp, d)
                 # using `tell` is a bit lazy, but we are not here for speed
                 start = tmp_storage.tell()
                 tmp_storage.write(d.data[1])
                 end = tmp_storage.tell()
                 rewritten_entries[rev] = (d.base, start, end, comp_mode)
     return rewritten_entries
 
 
 def _setup_new_files(
     revlog,
     index_cutoff,
     data_cutoff,
     sidedata_cutoff,
 ):
     """
 
     return a context manager to open all the relevant files:
     - old_data_file,
     - old_sidedata_file,
     - new_index_file,
     - new_data_file,
     - new_sidedata_file,
 
     The old_index_file is not here because it is accessed through the
     `old_index` object if the caller function.
     """
     docket = revlog._docket
     old_index_filepath = revlog.opener.join(docket.index_filepath())
     old_data_filepath = revlog.opener.join(docket.data_filepath())
     old_sidedata_filepath = revlog.opener.join(docket.sidedata_filepath())
 
     new_index_filepath = revlog.opener.join(docket.new_index_file())
     new_data_filepath = revlog.opener.join(docket.new_data_file())
     new_sidedata_filepath = revlog.opener.join(docket.new_sidedata_file())
 
     util.copyfile(old_index_filepath, new_index_filepath, nb_bytes=index_cutoff)
     util.copyfile(old_data_filepath, new_data_filepath, nb_bytes=data_cutoff)
     util.copyfile(
         old_sidedata_filepath,
         new_sidedata_filepath,
         nb_bytes=sidedata_cutoff,
     )
     revlog.opener.register_file(docket.index_filepath())
     revlog.opener.register_file(docket.data_filepath())
     revlog.opener.register_file(docket.sidedata_filepath())
 
     docket.index_end = index_cutoff
     docket.data_end = data_cutoff
     docket.sidedata_end = sidedata_cutoff
 
     # reload the revlog internal information
     revlog.clearcaches()
     revlog._loadindex(docket=docket)
 
     @contextlib.contextmanager
     def all_files_opener():
         # hide opening in an helper function to please check-code, black
         # and various python version at the same time
         with open(old_data_filepath, 'rb') as old_data_file:
             with open(old_sidedata_filepath, 'rb') as old_sidedata_file:
                 with open(new_index_filepath, 'r+b') as new_index_file:
                     with open(new_data_filepath, 'r+b') as new_data_file:
                         with open(
                             new_sidedata_filepath, 'r+b'
                         ) as new_sidedata_file:
                             new_index_file.seek(0, os.SEEK_END)
                             assert new_index_file.tell() == index_cutoff
                             new_data_file.seek(0, os.SEEK_END)
                             assert new_data_file.tell() == data_cutoff
                             new_sidedata_file.seek(0, os.SEEK_END)
                             assert new_sidedata_file.tell() == sidedata_cutoff
                             yield (
                                 old_data_file,
                                 old_sidedata_file,
                                 new_index_file,
                                 new_data_file,
                                 new_sidedata_file,
                             )
 
     return all_files_opener
 
 
 def _rewrite_simple(
     revlog,
     old_index,
     all_files,
     rev,
     rewritten_entries,
     tmp_storage,
 ):
     """append a normal revision to the index after the rewritten one(s)"""
     (
         old_data_file,
         old_sidedata_file,
         new_index_file,
         new_data_file,
         new_sidedata_file,
     ) = all_files
     entry = old_index[rev]
     flags = entry[ENTRY_DATA_OFFSET] & 0xFFFF
     old_data_offset = entry[ENTRY_DATA_OFFSET] >> 16
 
     if rev not in rewritten_entries:
         old_data_file.seek(old_data_offset)
         new_data_size = entry[ENTRY_DATA_COMPRESSED_LENGTH]
         new_data = old_data_file.read(new_data_size)
         data_delta_base = entry[ENTRY_DELTA_BASE]
         d_comp_mode = entry[ENTRY_DATA_COMPRESSION_MODE]
     else:
         (
             data_delta_base,
             start,
             end,
             d_comp_mode,
         ) = rewritten_entries[rev]
         new_data_size = end - start
         tmp_storage.seek(start)
         new_data = tmp_storage.read(new_data_size)
 
     # It might be faster to group continuous read/write operation,
     # however, this is censor, an operation that is not focussed
     # around stellar performance. So I have not written this
     # optimisation yet.
     new_data_offset = new_data_file.tell()
     new_data_file.write(new_data)
 
     sidedata_size = entry[ENTRY_SIDEDATA_COMPRESSED_LENGTH]
     new_sidedata_offset = new_sidedata_file.tell()
     if 0 < sidedata_size:
         old_sidedata_offset = entry[ENTRY_SIDEDATA_OFFSET]
         old_sidedata_file.seek(old_sidedata_offset)
         new_sidedata = old_sidedata_file.read(sidedata_size)
         new_sidedata_file.write(new_sidedata)
 
     data_uncompressed_length = entry[ENTRY_DATA_UNCOMPRESSED_LENGTH]
     sd_com_mode = entry[ENTRY_SIDEDATA_COMPRESSION_MODE]
     assert data_delta_base <= rev, (data_delta_base, rev)
 
     new_entry = revlogutils.entry(
         flags=flags,
         data_offset=new_data_offset,
         data_compressed_length=new_data_size,
         data_uncompressed_length=data_uncompressed_length,
         data_delta_base=data_delta_base,
         link_rev=entry[ENTRY_LINK_REV],
         parent_rev_1=entry[ENTRY_PARENT_1],
         parent_rev_2=entry[ENTRY_PARENT_2],
         node_id=entry[ENTRY_NODE_ID],
         sidedata_offset=new_sidedata_offset,
         sidedata_compressed_length=sidedata_size,
         data_compression_mode=d_comp_mode,
         sidedata_compression_mode=sd_com_mode,
     )
     revlog.index.append(new_entry)
     entry_bin = revlog.index.entry_binary(rev)
     new_index_file.write(entry_bin)
 
     revlog._docket.index_end = new_index_file.tell()
     revlog._docket.data_end = new_data_file.tell()
     revlog._docket.sidedata_end = new_sidedata_file.tell()
 
 
 def _rewrite_censor(
     revlog,
     old_index,
     all_files,
     rev,
     tombstone,
 ):
     """rewrite and append a censored revision"""
     (
         old_data_file,
         old_sidedata_file,
         new_index_file,
         new_data_file,
         new_sidedata_file,
     ) = all_files
     entry = old_index[rev]
 
     # XXX consider trying the default compression too
     new_data_size = len(tombstone)
     new_data_offset = new_data_file.tell()
     new_data_file.write(tombstone)
 
     # we are not adding any sidedata as they might leak info about the censored version
 
     link_rev = entry[ENTRY_LINK_REV]
 
     p1 = entry[ENTRY_PARENT_1]
     p2 = entry[ENTRY_PARENT_2]
 
     new_entry = revlogutils.entry(
         flags=constants.REVIDX_ISCENSORED,
         data_offset=new_data_offset,
         data_compressed_length=new_data_size,
         data_uncompressed_length=new_data_size,
         data_delta_base=rev,
         link_rev=link_rev,
         parent_rev_1=p1,
         parent_rev_2=p2,
         node_id=entry[ENTRY_NODE_ID],
         sidedata_offset=0,
         sidedata_compressed_length=0,
         data_compression_mode=COMP_MODE_PLAIN,
         sidedata_compression_mode=COMP_MODE_PLAIN,
     )
     revlog.index.append(new_entry)
     entry_bin = revlog.index.entry_binary(rev)
     new_index_file.write(entry_bin)
     revlog._docket.index_end = new_index_file.tell()
     revlog._docket.data_end = new_data_file.tell()
 
 
 def _get_filename_from_filelog_index(path):
     # Drop the extension and the `data/` prefix
     path_part = path.rsplit(b'.', 1)[0].split(b'/', 1)
     if len(path_part) < 2:
         msg = _(b"cannot recognize filelog from filename: '%s'")
         msg %= path
         raise error.Abort(msg)
 
     return path_part[1]
 
 
 def _filelog_from_filename(repo, path):
     """Returns the filelog for the given `path`. Stolen from `engine.py`"""
 
     from .. import filelog  # avoid cycle
 
     fl = filelog.filelog(repo.svfs, path)
     return fl
 
 
 def _write_swapped_parents(repo, rl, rev, offset, fp):
     """Swaps p1 and p2 and overwrites the revlog entry for `rev` in `fp`"""
     from ..pure import parsers  # avoid cycle
 
     if repo._currentlock(repo._lockref) is None:
         # Let's be paranoid about it
         msg = "repo needs to be locked to rewrite parents"
         raise error.ProgrammingError(msg)
 
     index_format = parsers.IndexObject.index_format
     entry = rl.index[rev]
     new_entry = list(entry)
     new_entry[5], new_entry[6] = entry[6], entry[5]
     packed = index_format.pack(*new_entry[:8])
     fp.seek(offset)
     fp.write(packed)
 
 
 def _reorder_filelog_parents(repo, fl, to_fix):
     """
     Swaps p1 and p2 for all `to_fix` revisions of filelog `fl` and writes the
     new version to disk, overwriting the old one with a rename.
     """
     from ..pure import parsers  # avoid cycle
 
     ui = repo.ui
     assert len(to_fix) > 0
     rl = fl._revlog
     if rl._format_version != constants.REVLOGV1:
         msg = "expected version 1 revlog, got version '%d'" % rl._format_version
         raise error.ProgrammingError(msg)
 
     index_file = rl._indexfile
     new_file_path = index_file + b'.tmp-parents-fix'
     repaired_msg = _(b"repaired revision %d of 'filelog %s'\n")
 
     with ui.uninterruptible():
         try:
             util.copyfile(
                 rl.opener.join(index_file),
                 rl.opener.join(new_file_path),
                 checkambig=rl._checkambig,
             )
 
             with rl.opener(new_file_path, mode=b"r+") as fp:
                 if rl._inline:
                     index = parsers.InlinedIndexObject(fp.read())
                     for rev in fl.revs():
                         if rev in to_fix:
                             offset = index._calculate_index(rev)
                             _write_swapped_parents(repo, rl, rev, offset, fp)
                             ui.write(repaired_msg % (rev, index_file))
                 else:
                     index_format = parsers.IndexObject.index_format
                     for rev in to_fix:
                         offset = rev * index_format.size
                         _write_swapped_parents(repo, rl, rev, offset, fp)
                         ui.write(repaired_msg % (rev, index_file))
 
             rl.opener.rename(new_file_path, index_file)
             rl.clearcaches()
             rl._loadindex()
         finally:
             util.tryunlink(new_file_path)
 
 
 def _is_revision_affected(fl, filerev, metadata_cache=None):
     full_text = lambda: fl._revlog.rawdata(filerev)
     parent_revs = lambda: fl._revlog.parentrevs(filerev)
     return _is_revision_affected_inner(
         full_text, parent_revs, filerev, metadata_cache
     )
 
 
 def _is_revision_affected_inner(
     full_text,
     parents_revs,
     filerev,
     metadata_cache=None,
 ):
     """Mercurial currently (5.9rc0) uses `p1 == nullrev and p2 != nullrev` as a
     special meaning compared to the reverse in the context of filelog-based
     copytracing. issue6528 exists because new code assumed that parent ordering
     didn't matter, so this detects if the revision contains metadata (since
     it's only used for filelog-based copytracing) and its parents are in the
     "wrong" order."""
     try:
         raw_text = full_text()
     except error.CensoredNodeError:
         # We don't care about censored nodes as they never carry metadata
         return False
 
     # raw text can be a `memoryview`, which doesn't implement `startswith`
     has_meta = bytes(raw_text[:2]) == b'\x01\n'
     if metadata_cache is not None:
         metadata_cache[filerev] = has_meta
     if has_meta:
         (p1, p2) = parents_revs()
         if p1 != nullrev and p2 == nullrev:
             return True
     return False
 
 
 def _is_revision_affected_fast(repo, fl, filerev, metadata_cache):
     rl = fl._revlog
     is_censored = lambda: rl.iscensored(filerev)
     delta_base = lambda: rl.deltaparent(filerev)
     delta = lambda: rl._chunk(filerev)
     full_text = lambda: rl.rawdata(filerev)
     parent_revs = lambda: rl.parentrevs(filerev)
     return _is_revision_affected_fast_inner(
         is_censored,
         delta_base,
         delta,
         full_text,
         parent_revs,
         filerev,
         metadata_cache,
     )
 
 
 def _is_revision_affected_fast_inner(
     is_censored,
     delta_base,
     delta,
     full_text,
     parent_revs,
     filerev,
     metadata_cache,
 ):
     """Optimization fast-path for `_is_revision_affected`.
 
     `metadata_cache` is a dict of `{rev: has_metadata}` which allows any
     revision to check if its base has metadata, saving computation of the full
     text, instead looking at the current delta.
 
     This optimization only works if the revisions are looked at in order."""
 
     if is_censored():
         # Censored revisions don't contain metadata, so they cannot be affected
         metadata_cache[filerev] = False
         return False
 
     p1, p2 = parent_revs()
     if p1 == nullrev or p2 != nullrev:
         return False
 
     delta_parent = delta_base()
     parent_has_metadata = metadata_cache.get(delta_parent)
     if parent_has_metadata is None:
         return _is_revision_affected_inner(
             full_text,
             parent_revs,
             filerev,
             metadata_cache,
         )
 
     chunk = delta()
     if not len(chunk):
         # No diff for this revision
         return parent_has_metadata
 
     header_length = 12
     if len(chunk) < header_length:
         raise error.Abort(_(b"patch cannot be decoded"))
 
     start, _end, _length = struct.unpack(b">lll", chunk[:header_length])
 
     if start < 2:  # len(b'\x01\n') == 2
         # This delta does *something* to the metadata marker (if any).
         # Check it the slow way
         is_affected = _is_revision_affected_inner(
             full_text,
             parent_revs,
             filerev,
             metadata_cache,
         )
         return is_affected
 
     # The diff did not remove or add the metadata header, it's then in the same
     # situation as its parent
     metadata_cache[filerev] = parent_has_metadata
     return parent_has_metadata
 
 
 def _from_report(ui, repo, context, from_report, dry_run):
     """
     Fix the revisions given in the `from_report` file, but still checks if the
     revisions are indeed affected to prevent an unfortunate cyclic situation
     where we'd swap well-ordered parents again.
 
     See the doc for `debug_fix_issue6528` for the format documentation.
     """
     ui.write(_(b"loading report file '%s'\n") % from_report)
 
     with context(), open(from_report, mode='rb') as f:
         for line in f.read().split(b'\n'):
             if not line:
                 continue
             filenodes, filename = line.split(b' ', 1)
             fl = _filelog_from_filename(repo, filename)
             to_fix = set(
                 fl.rev(binascii.unhexlify(n)) for n in filenodes.split(b',')
             )
             excluded = set()
 
             for filerev in to_fix:
                 if _is_revision_affected(fl, filerev):
                     msg = b"found affected revision %d for filelog '%s'\n"
                     ui.warn(msg % (filerev, filename))
                 else:
                     msg = _(b"revision %s of file '%s' is not affected\n")
                     msg %= (binascii.hexlify(fl.node(filerev)), filename)
                     ui.warn(msg)
                     excluded.add(filerev)
 
             to_fix = to_fix - excluded
             if not to_fix:
                 msg = _(b"no affected revisions were found for '%s'\n")
                 ui.write(msg % filename)
                 continue
             if not dry_run:
                 _reorder_filelog_parents(repo, fl, sorted(to_fix))
 
 
 def filter_delta_issue6528(revlog, deltas_iter):
     """filter incomind deltas to repaire issue 6528 on the fly"""
     metadata_cache = {}
 
     deltacomputer = deltas.deltacomputer(revlog)
 
     for rev, d in enumerate(deltas_iter, len(revlog)):
         (
             node,
             p1_node,
             p2_node,
             linknode,
             deltabase,
             delta,
             flags,
             sidedata,
         ) = d
 
         if not revlog.index.has_node(deltabase):
             raise error.LookupError(
                 deltabase, revlog.radix, _(b'unknown parent')
             )
         base_rev = revlog.rev(deltabase)
         if not revlog.index.has_node(p1_node):
             raise error.LookupError(p1_node, revlog.radix, _(b'unknown parent'))
         p1_rev = revlog.rev(p1_node)
         if not revlog.index.has_node(p2_node):
             raise error.LookupError(p2_node, revlog.radix, _(b'unknown parent'))
         p2_rev = revlog.rev(p2_node)
 
         is_censored = lambda: bool(flags & REVIDX_ISCENSORED)
         delta_base = lambda: revlog.rev(delta_base)
         delta_base = lambda: base_rev
         parent_revs = lambda: (p1_rev, p2_rev)
 
         def full_text():
             # note: being able to reuse the full text computation in the
             # underlying addrevision would be useful however this is a bit too
             # intrusive the for the "quick" issue6528 we are writing before the
             # 5.8 release
             textlen = mdiff.patchedsize(revlog.size(base_rev), delta)
 
             revinfo = revlogutils.revisioninfo(
                 node,
                 p1_node,
                 p2_node,
                 [None],
                 textlen,
                 (base_rev, delta),
                 flags,
             )
             # cached by the global "writing" context
             assert revlog._writinghandles is not None
             if revlog._inline:
                 fh = revlog._writinghandles[0]
             else:
                 fh = revlog._writinghandles[1]
             return deltacomputer.buildtext(revinfo, fh)
 
         is_affected = _is_revision_affected_fast_inner(
             is_censored,
             delta_base,
             lambda: delta,
             full_text,
             parent_revs,
             rev,
             metadata_cache,
         )
         if is_affected:
             d = (
                 node,
                 p2_node,
                 p1_node,
                 linknode,
                 deltabase,
                 delta,
                 flags,
                 sidedata,
             )
         yield d
 
 
 def repair_issue6528(
     ui, repo, dry_run=False, to_report=None, from_report=None, paranoid=False
 ):
     from .. import store  # avoid cycle
 
     @contextlib.contextmanager
     def context():
         if dry_run or to_report:  # No need for locking
             yield
         else:
             with repo.wlock(), repo.lock():
                 yield
 
     if from_report:
         return _from_report(ui, repo, context, from_report, dry_run)
 
     report_entries = []
 
     with context():
         files = list(
             entry
             for entry in repo.store.datafiles()
             if (
-                entry.is_revlog
-                and entry.is_revlog_main
-                and entry.revlog_type == store.FILEFLAGS_FILELOG
+                entry.is_revlog and entry.revlog_type == store.FILEFLAGS_FILELOG
             )
         )
 
         progress = ui.makeprogress(
             _(b"looking for affected revisions"),
             unit=_(b"filelogs"),
             total=len(files),
         )
         found_nothing = True
 
         for entry in files:
             progress.increment()
             filename = entry.target_id
             fl = _filelog_from_filename(repo, entry.target_id)
 
             # Set of filerevs (or hex filenodes if `to_report`) that need fixing
             to_fix = set()
             metadata_cache = {}
             for filerev in fl.revs():
                 affected = _is_revision_affected_fast(
                     repo, fl, filerev, metadata_cache
                 )
                 if paranoid:
                     slow = _is_revision_affected(fl, filerev)
                     if slow != affected:
                         msg = _(b"paranoid check failed for '%s' at node %s")
                         node = binascii.hexlify(fl.node(filerev))
                         raise error.Abort(msg % (filename, node))
                 if affected:
                     msg = b"found affected revision %d for file '%s'\n"
                     ui.warn(msg % (filerev, filename))
                     found_nothing = False
                     if not dry_run:
                         if to_report:
                             to_fix.add(binascii.hexlify(fl.node(filerev)))
                         else:
                             to_fix.add(filerev)
 
             if to_fix:
                 to_fix = sorted(to_fix)
                 if to_report:
                     report_entries.append((filename, to_fix))
                 else:
                     _reorder_filelog_parents(repo, fl, to_fix)
 
         if found_nothing:
             ui.write(_(b"no affected revisions were found\n"))
 
         if to_report and report_entries:
             with open(to_report, mode="wb") as f:
                 for path, to_fix in report_entries:
                     f.write(b"%s %s\n" % (b",".join(to_fix), path))
 
         progress.complete()

mercurial/store.py

@@ -1,1056 +1,1067
 # 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.
 
 import collections
 import functools
 import os
 import re
 import stat
 from typing import Generator
 
 from .i18n import _
 from .pycompat import getattr
 from .thirdparty import attr
 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 _match_tracked_entry(entry, 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
     if entry.revlog_type == FILEFLAGS_FILELOG:
         return matcher(entry.target_id)
     elif entry.revlog_type == FILEFLAGS_MANIFESTLOG:
         return matcher.visitdir(entry.target_id.rstrip(b'/'))
     raise error.ProgrammingError(b"cannot process entry %r" % entry)
 
 
 # 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 cmap.items():
         dmap[v] = k
 
     def decode(s):
         i = 0
         while i < len(s):
             for l in range(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 range(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 range(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',)
 REVLOG_FILES_OTHER_EXT = (
     b'.idx',
     b'.d',
     b'.dat',
     b'.n',
     b'.nd',
     b'.sda',
 )
 # file extension that also use a `-SOMELONGIDHASH.ext` form
 REVLOG_FILES_LONG_EXT = (
     b'.nd',
     b'.idx',
     b'.dat',
     b'.sda',
 )
 # 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
 #
 # XXX This is currently not in use because of issue6542
 EXCLUDED = re.compile(br'.*undo\.[^/]+\.(nd?|i)$')
 
 
 def is_revlog(f, kind, st):
     if kind != stat.S_IFREG:
         return None
     return revlog_type(f)
 
 
 def revlog_type(f):
     # XXX we need to filter `undo.` created by the transaction here, however
     # being naive about it also filter revlog for `undo.*` files, leading to
     # issue6542. So we no longer use EXCLUDED.
     if f.endswith(REVLOG_FILES_MAIN_EXT):
         return FILEFLAGS_REVLOG_MAIN
     elif f.endswith(REVLOG_FILES_OTHER_EXT):
         t = FILETYPE_FILELOG_OTHER
         if f.endswith(REVLOG_FILES_VOLATILE_EXT):
             t |= FILEFLAGS_VOLATILE
         return t
     return None
 
 
 # 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
 
 
 @attr.s(slots=True, init=False)
 class BaseStoreEntry:
     """An entry in the store
 
     This is returned by `store.walk` and represent some data in the store."""
 
+
+@attr.s(slots=True, init=False)
+class SimpleStoreEntry(BaseStoreEntry):
+    """A generic entry in the store"""
+
+    is_revlog = False
+
     _entry_path = attr.ib()
     _is_volatile = attr.ib(default=False)
     _file_size = attr.ib(default=None)
 
     def __init__(
         self,
         entry_path,
         is_volatile=False,
         file_size=None,
     ):
+        super().__init__()
         self._entry_path = entry_path
         self._is_volatile = is_volatile
         self._file_size = file_size
 
     def files(self):
         return [
             StoreFile(
                 unencoded_path=self._entry_path,
                 file_size=self._file_size,
                 is_volatile=self._is_volatile,
             )
         ]
 
 
 @attr.s(slots=True, init=False)
-class SimpleStoreEntry(BaseStoreEntry):
-    """A generic entry in the store"""
-
-    is_revlog = False
-
-
-@attr.s(slots=True, init=False)
 class RevlogStoreEntry(BaseStoreEntry):
     """A revlog entry in the store"""
 
     is_revlog = True
+
     revlog_type = attr.ib(default=None)
     target_id = attr.ib(default=None)
-    is_revlog_main = attr.ib(default=None)
+    _path_prefix = attr.ib(default=None)
+    _details = attr.ib(default=None)
 
     def __init__(
         self,
-        entry_path,
         revlog_type,
+        path_prefix,
         target_id,
-        is_revlog_main=False,
-        is_volatile=False,
-        file_size=None,
+        details,
     ):
-        super().__init__(
-            entry_path=entry_path,
-            is_volatile=is_volatile,
-            file_size=file_size,
-        )
+        super().__init__()
         self.revlog_type = revlog_type
         self.target_id = target_id
-        self.is_revlog_main = is_revlog_main
+        self._path_prefix = path_prefix
+        assert b'.i' in details, (path_prefix, details)
+        self._details = details
 
     def main_file_path(self):
         """unencoded path of the main revlog file"""
-        return self._entry_path
+        return self._path_prefix + b'.i'
+
+    def files(self):
+        files = []
+        for ext in sorted(self._details, key=_ext_key):
+            path = self._path_prefix + ext
+            data = self._details[ext]
+            files.append(StoreFile(unencoded_path=path, **data))
+        return files
 
 
 @attr.s(slots=True)
 class StoreFile:
     """a file matching an entry"""
 
     unencoded_path = attr.ib()
-    _file_size = attr.ib(default=False)
+    _file_size = attr.ib(default=None)
     is_volatile = attr.ib(default=False)
 
     def file_size(self, vfs):
         if self._file_size is not None:
             return self._file_size
         try:
             return vfs.stat(self.unencoded_path).st_size
         except FileNotFoundError:
             return 0
 
 
 def _gather_revlog(files_data):
     """group files per revlog prefix
 
     The returns a two level nested dict. The top level key is the revlog prefix
     without extension, the second level is all the file "suffix" that were
     seen for this revlog and arbitrary file data as value.
     """
     revlogs = collections.defaultdict(dict)
     for u, value in files_data:
         name, ext = _split_revlog_ext(u)
         revlogs[name][ext] = value
     return sorted(revlogs.items())
 
 
 def _split_revlog_ext(filename):
     """split the revlog file prefix from the variable extension"""
     if filename.endswith(REVLOG_FILES_LONG_EXT):
         char = b'-'
     else:
         char = b'.'
     idx = filename.rfind(char)
     return filename[:idx], filename[idx:]
 
 
 def _ext_key(ext):
     """a key to order revlog suffix
 
     important to issue .i after other entry."""
     # the only important part of this order is to keep the `.i` last.
     if ext.endswith(b'.n'):
         return (0, ext)
     elif ext.endswith(b'.nd'):
         return (10, ext)
     elif ext.endswith(b'.d'):
         return (20, ext)
     elif ext.endswith(b'.i'):
         return (50, ext)
     else:
         return (40, ext)
 
 
 class basicstore:
     '''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, undecodable=None):
         '''yields (revlog_type, unencoded, 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((decodedir(n), (rl_type, 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, undecodable=None
     ) -> Generator[BaseStoreEntry, None, None]:
         """Like walk, but excluding the changelog and root manifest.
 
         When [undecodable] is None, revlogs names that can't be
         decoded cause an exception. When it is provided, it should
         be a list and the filenames that can't be decoded are added
         to it instead. This is very rarely needed."""
         dirs = [
             (b'data', FILEFLAGS_FILELOG),
             (b'meta', FILEFLAGS_MANIFESTLOG),
         ]
         for base_dir, rl_type in dirs:
             files = self._walk(base_dir, True, undecodable=undecodable)
             files = (f for f in files if f[1][0] is not None)
             for revlog, details in _gather_revlog(files):
+                file_details = {}
+                revlog_target_id = revlog.split(b'/', 1)[1]
                 for ext, (t, s) in sorted(details.items()):
-                    u = revlog + ext
-                    revlog_target_id = revlog.split(b'/', 1)[1]
-                    yield RevlogStoreEntry(
-                        entry_path=u,
-                        revlog_type=rl_type,
-                        target_id=revlog_target_id,
-                        is_revlog_main=bool(t & FILEFLAGS_REVLOG_MAIN),
-                        is_volatile=bool(t & FILEFLAGS_VOLATILE),
-                        file_size=s,
-                    )
+                    file_details[ext] = {
+                        'is_volatile': bool(t & FILEFLAGS_VOLATILE),
+                        'file_size': s,
+                    }
+                yield RevlogStoreEntry(
+                    path_prefix=revlog,
+                    revlog_type=rl_type,
+                    target_id=revlog_target_id,
+                    details=file_details,
+                )
 
     def topfiles(self) -> Generator[BaseStoreEntry, None, None]:
         files = reversed(self._walk(b'', False))
 
         changelogs = collections.defaultdict(dict)
         manifestlogs = collections.defaultdict(dict)
 
         for u, (t, s) in files:
             if u.startswith(b'00changelog'):
                 name, ext = _split_revlog_ext(u)
                 changelogs[name][ext] = (t, s)
             elif u.startswith(b'00manifest'):
                 name, ext = _split_revlog_ext(u)
                 manifestlogs[name][ext] = (t, s)
             else:
                 yield SimpleStoreEntry(
                     entry_path=u,
                     is_volatile=bool(t & FILEFLAGS_VOLATILE),
                     file_size=s,
                 )
         # yield manifest before changelog
         top_rl = [
             (manifestlogs, FILEFLAGS_MANIFESTLOG),
             (changelogs, FILEFLAGS_CHANGELOG),
         ]
         assert len(manifestlogs) <= 1
         assert len(changelogs) <= 1
         for data, revlog_type in top_rl:
             for revlog, details in sorted(data.items()):
-                # (keeping ordering so we get 00changelog.i last)
-                key = lambda x: _ext_key(x[0])
-                for ext, (t, s) in sorted(details.items(), key=key):
-                    u = revlog + ext
-                    yield RevlogStoreEntry(
-                        entry_path=u,
-                        revlog_type=revlog_type,
-                        target_id=b'',
-                        is_revlog_main=bool(t & FILEFLAGS_REVLOG_MAIN),
-                        is_volatile=bool(t & FILEFLAGS_VOLATILE),
-                        file_size=s,
-                    )
+                file_details = {}
+                for ext, (t, s) in details.items():
+                    file_details[ext] = {
+                        'is_volatile': bool(t & FILEFLAGS_VOLATILE),
+                        'file_size': s,
+                    }
+                yield RevlogStoreEntry(
+                    path_prefix=revlog,
+                    revlog_type=revlog_type,
+                    target_id=b'',
+                    details=file_details,
+                )
 
     def walk(self, matcher=None) -> Generator[BaseStoreEntry, None, None]:
         """return files related to data storage (ie: revlogs)
 
         yields (file_type, unencoded, 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 _walk(self, relpath, recurse, undecodable=None):
         old = super()._walk(relpath, recurse)
         new = []
         for f1, value in old:
             try:
                 f2 = decodefilename(f1)
             except KeyError:
                 if undecodable is None:
                     msg = _(b'undecodable revlog name %s') % f1
                     raise error.StorageError(msg)
                 else:
                     undecodable.append(f1)
                     continue
             new.append((f2, value))
         return new
 
     def datafiles(
         self, matcher=None, undecodable=None
     ) -> Generator[BaseStoreEntry, None, None]:
         entries = super(encodedstore, self).datafiles(undecodable=undecodable)
         for entry in entries:
             if _match_tracked_entry(entry, matcher):
                 yield entry
 
     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:
     # the filename used to be partially encoded
     # hence the encodedir/decodedir dance
     def __init__(self, vfs):
         self.vfs = vfs
         self._ignores = set()
         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(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 addignore(self, fn):
         self._ignores.add(fn)
 
     def add(self, fn):
         if fn in self._ignores:
             return
         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/'))
             and revlog_type(path) is not None
         ):
             # 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'r+' 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)
 
     def register_file(self, path):
         """generic hook point to lets fncache steer its stew"""
         if path.startswith(b'data/') or path.startswith(b'meta/'):
             self.fncache.add(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, undecodable=None
     ) -> Generator[BaseStoreEntry, None, None]:
         files = ((f, revlog_type(f)) for f in self.fncache)
         # Note: all files in fncache should be revlog related, However the
         # fncache might contains such file added by previous version of
         # Mercurial.
         files = (f for f in files if f[1] is not None)
         by_revlog = _gather_revlog(files)
         for revlog, details in by_revlog:
+            file_details = {}
             if revlog.startswith(b'data/'):
                 rl_type = FILEFLAGS_FILELOG
                 revlog_target_id = revlog.split(b'/', 1)[1]
             elif revlog.startswith(b'meta/'):
                 rl_type = FILEFLAGS_MANIFESTLOG
                 # drop the initial directory and the `00manifest` file part
                 tmp = revlog.split(b'/', 1)[1]
                 revlog_target_id = tmp.rsplit(b'/', 1)[0] + b'/'
             else:
                 # unreachable
                 assert False, revlog
-            for ext, t in sorted(details.items()):
-                f = revlog + ext
-                entry = RevlogStoreEntry(
-                    entry_path=f,
-                    revlog_type=rl_type,
-                    target_id=revlog_target_id,
-                    is_revlog_main=bool(t & FILEFLAGS_REVLOG_MAIN),
-                    is_volatile=bool(t & FILEFLAGS_VOLATILE),
-                )
-                if _match_tracked_entry(entry, matcher):
-                    yield entry
+            for ext, t in details.items():
+                file_details[ext] = {
+                    'is_volatile': bool(t & FILEFLAGS_VOLATILE),
+                }
+            entry = RevlogStoreEntry(
+                path_prefix=revlog,
+                revlog_type=rl_type,
+                target_id=revlog_target_id,
+                details=file_details,
+            )
+            if _match_tracked_entry(entry, matcher):
+                yield entry
 
     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 FileNotFoundError:
             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

mercurial/upgrade_utils/engine.py

@@ -1,668 +1,668
 # upgrade.py - functions for in place upgrade of Mercurial repository
 #
 # Copyright (c) 2016-present, Gregory Szorc
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 import stat
 
 from ..i18n import _
 from ..pycompat import getattr
 from .. import (
     changelog,
     error,
     filelog,
     manifest,
     metadata,
     pycompat,
     requirements,
     scmutil,
     store,
     util,
     vfs as vfsmod,
 )
 from ..revlogutils import (
     constants as revlogconst,
     flagutil,
     nodemap,
     sidedata as sidedatamod,
 )
 from . import actions as upgrade_actions
 
 
 def get_sidedata_helpers(srcrepo, dstrepo):
     use_w = srcrepo.ui.configbool(b'experimental', b'worker.repository-upgrade')
     sequential = pycompat.iswindows or not use_w
     if not sequential:
         srcrepo.register_sidedata_computer(
             revlogconst.KIND_CHANGELOG,
             sidedatamod.SD_FILES,
             (sidedatamod.SD_FILES,),
             metadata._get_worker_sidedata_adder(srcrepo, dstrepo),
             flagutil.REVIDX_HASCOPIESINFO,
             replace=True,
         )
     return sidedatamod.get_sidedata_helpers(srcrepo, dstrepo._wanted_sidedata)
 
 
 def _revlog_from_store_entry(repo, entry):
     """Obtain a revlog from a repo store entry.
 
     An instance of the appropriate class is returned.
     """
     if entry.revlog_type == store.FILEFLAGS_CHANGELOG:
         return changelog.changelog(repo.svfs)
     elif entry.revlog_type == store.FILEFLAGS_MANIFESTLOG:
         mandir = entry.target_id.rstrip(b'/')
         return manifest.manifestrevlog(
             repo.nodeconstants, repo.svfs, tree=mandir
         )
     else:
         return filelog.filelog(repo.svfs, entry.target_id)
 
 
 def _copyrevlog(tr, destrepo, oldrl, entry):
     """copy all relevant files for `oldrl` into `destrepo` store
 
     Files are copied "as is" without any transformation. The copy is performed
     without extra checks. Callers are responsible for making sure the copied
     content is compatible with format of the destination repository.
     """
     oldrl = getattr(oldrl, '_revlog', oldrl)
     newrl = _revlog_from_store_entry(destrepo, entry)
     newrl = getattr(newrl, '_revlog', newrl)
 
     oldvfs = oldrl.opener
     newvfs = newrl.opener
     oldindex = oldvfs.join(oldrl._indexfile)
     newindex = newvfs.join(newrl._indexfile)
     olddata = oldvfs.join(oldrl._datafile)
     newdata = newvfs.join(newrl._datafile)
 
     with newvfs(newrl._indexfile, b'w'):
         pass  # create all the directories
 
     util.copyfile(oldindex, newindex)
     copydata = oldrl.opener.exists(oldrl._datafile)
     if copydata:
         util.copyfile(olddata, newdata)
 
     if entry.revlog_type & store.FILEFLAGS_FILELOG:
         unencodedname = entry.main_file_path()
         destrepo.svfs.fncache.add(unencodedname)
         if copydata:
             destrepo.svfs.fncache.add(unencodedname[:-2] + b'.d')
 
 
 UPGRADE_CHANGELOG = b"changelog"
 UPGRADE_MANIFEST = b"manifest"
 UPGRADE_FILELOGS = b"all-filelogs"
 
 UPGRADE_ALL_REVLOGS = frozenset(
     [UPGRADE_CHANGELOG, UPGRADE_MANIFEST, UPGRADE_FILELOGS]
 )
 
 
 def matchrevlog(revlogfilter, rl_type):
     """check if a revlog is selected for cloning.
 
     In other words, are there any updates which need to be done on revlog
     or it can be blindly copied.
 
     The store entry is checked against the passed filter"""
     if rl_type & store.FILEFLAGS_CHANGELOG:
         return UPGRADE_CHANGELOG in revlogfilter
     elif rl_type & store.FILEFLAGS_MANIFESTLOG:
         return UPGRADE_MANIFEST in revlogfilter
     assert rl_type & store.FILEFLAGS_FILELOG
     return UPGRADE_FILELOGS in revlogfilter
 
 
 def _perform_clone(
     ui,
     dstrepo,
     tr,
     old_revlog,
     entry,
     upgrade_op,
     sidedata_helpers,
     oncopiedrevision,
 ):
     """returns the new revlog object created"""
     newrl = None
     revlog_path = entry.main_file_path()
     if matchrevlog(upgrade_op.revlogs_to_process, entry.revlog_type):
         ui.note(
             _(b'cloning %d revisions from %s\n')
             % (len(old_revlog), revlog_path)
         )
         newrl = _revlog_from_store_entry(dstrepo, entry)
         old_revlog.clone(
             tr,
             newrl,
             addrevisioncb=oncopiedrevision,
             deltareuse=upgrade_op.delta_reuse_mode,
             forcedeltabothparents=upgrade_op.force_re_delta_both_parents,
             sidedata_helpers=sidedata_helpers,
         )
     else:
         msg = _(b'blindly copying %s containing %i revisions\n')
         ui.note(msg % (revlog_path, len(old_revlog)))
         _copyrevlog(tr, dstrepo, old_revlog, entry)
 
         newrl = _revlog_from_store_entry(dstrepo, entry)
     return newrl
 
 
 def _clonerevlogs(
     ui,
     srcrepo,
     dstrepo,
     tr,
     upgrade_op,
 ):
     """Copy revlogs between 2 repos."""
     revcount = 0
     srcsize = 0
     srcrawsize = 0
     dstsize = 0
     fcount = 0
     frevcount = 0
     fsrcsize = 0
     frawsize = 0
     fdstsize = 0
     mcount = 0
     mrevcount = 0
     msrcsize = 0
     mrawsize = 0
     mdstsize = 0
     crevcount = 0
     csrcsize = 0
     crawsize = 0
     cdstsize = 0
 
     alldatafiles = list(srcrepo.store.walk())
     # mapping of data files which needs to be cloned
     # key is unencoded filename
     # value is revlog_object_from_srcrepo
     manifests = {}
     changelogs = {}
     filelogs = {}
 
     # Perform a pass to collect metadata. This validates we can open all
     # source files and allows a unified progress bar to be displayed.
     for entry in alldatafiles:
-        if not (entry.is_revlog and entry.is_revlog_main):
+        if not entry.is_revlog:
             continue
 
         rl = _revlog_from_store_entry(srcrepo, entry)
 
         info = rl.storageinfo(
             exclusivefiles=True,
             revisionscount=True,
             trackedsize=True,
             storedsize=True,
         )
 
         revcount += info[b'revisionscount'] or 0
         datasize = info[b'storedsize'] or 0
         rawsize = info[b'trackedsize'] or 0
 
         srcsize += datasize
         srcrawsize += rawsize
 
         # This is for the separate progress bars.
         if entry.revlog_type & store.FILEFLAGS_CHANGELOG:
             changelogs[entry.target_id] = entry
             crevcount += len(rl)
             csrcsize += datasize
             crawsize += rawsize
         elif entry.revlog_type & store.FILEFLAGS_MANIFESTLOG:
             manifests[entry.target_id] = entry
             mcount += 1
             mrevcount += len(rl)
             msrcsize += datasize
             mrawsize += rawsize
         elif entry.revlog_type & store.FILEFLAGS_FILELOG:
             filelogs[entry.target_id] = entry
             fcount += 1
             frevcount += len(rl)
             fsrcsize += datasize
             frawsize += rawsize
         else:
             error.ProgrammingError(b'unknown revlog type')
 
     if not revcount:
         return
 
     ui.status(
         _(
             b'migrating %d total revisions (%d in filelogs, %d in manifests, '
             b'%d in changelog)\n'
         )
         % (revcount, frevcount, mrevcount, crevcount)
     )
     ui.status(
         _(b'migrating %s in store; %s tracked data\n')
         % ((util.bytecount(srcsize), util.bytecount(srcrawsize)))
     )
 
     # Used to keep track of progress.
     progress = None
 
     def oncopiedrevision(rl, rev, node):
         progress.increment()
 
     sidedata_helpers = get_sidedata_helpers(srcrepo, dstrepo)
 
     # Migrating filelogs
     ui.status(
         _(
             b'migrating %d filelogs containing %d revisions '
             b'(%s in store; %s tracked data)\n'
         )
         % (
             fcount,
             frevcount,
             util.bytecount(fsrcsize),
             util.bytecount(frawsize),
         )
     )
     progress = srcrepo.ui.makeprogress(_(b'file revisions'), total=frevcount)
     for target_id, entry in sorted(filelogs.items()):
         oldrl = _revlog_from_store_entry(srcrepo, entry)
 
         newrl = _perform_clone(
             ui,
             dstrepo,
             tr,
             oldrl,
             entry,
             upgrade_op,
             sidedata_helpers,
             oncopiedrevision,
         )
         info = newrl.storageinfo(storedsize=True)
         fdstsize += info[b'storedsize'] or 0
     ui.status(
         _(
             b'finished migrating %d filelog revisions across %d '
             b'filelogs; change in size: %s\n'
         )
         % (frevcount, fcount, util.bytecount(fdstsize - fsrcsize))
     )
 
     # Migrating manifests
     ui.status(
         _(
             b'migrating %d manifests containing %d revisions '
             b'(%s in store; %s tracked data)\n'
         )
         % (
             mcount,
             mrevcount,
             util.bytecount(msrcsize),
             util.bytecount(mrawsize),
         )
     )
     if progress:
         progress.complete()
     progress = srcrepo.ui.makeprogress(
         _(b'manifest revisions'), total=mrevcount
     )
     for target_id, entry in sorted(manifests.items()):
         oldrl = _revlog_from_store_entry(srcrepo, entry)
         newrl = _perform_clone(
             ui,
             dstrepo,
             tr,
             oldrl,
             entry,
             upgrade_op,
             sidedata_helpers,
             oncopiedrevision,
         )
         info = newrl.storageinfo(storedsize=True)
         mdstsize += info[b'storedsize'] or 0
     ui.status(
         _(
             b'finished migrating %d manifest revisions across %d '
             b'manifests; change in size: %s\n'
         )
         % (mrevcount, mcount, util.bytecount(mdstsize - msrcsize))
     )
 
     # Migrating changelog
     ui.status(
         _(
             b'migrating changelog containing %d revisions '
             b'(%s in store; %s tracked data)\n'
         )
         % (
             crevcount,
             util.bytecount(csrcsize),
             util.bytecount(crawsize),
         )
     )
     if progress:
         progress.complete()
     progress = srcrepo.ui.makeprogress(
         _(b'changelog revisions'), total=crevcount
     )
     for target_id, entry in sorted(changelogs.items()):
         oldrl = _revlog_from_store_entry(srcrepo, entry)
         newrl = _perform_clone(
             ui,
             dstrepo,
             tr,
             oldrl,
             entry,
             upgrade_op,
             sidedata_helpers,
             oncopiedrevision,
         )
         info = newrl.storageinfo(storedsize=True)
         cdstsize += info[b'storedsize'] or 0
     progress.complete()
     ui.status(
         _(
             b'finished migrating %d changelog revisions; change in size: '
             b'%s\n'
         )
         % (crevcount, util.bytecount(cdstsize - csrcsize))
     )
 
     dstsize = fdstsize + mdstsize + cdstsize
     ui.status(
         _(
             b'finished migrating %d total revisions; total change in store '
             b'size: %s\n'
         )
         % (revcount, util.bytecount(dstsize - srcsize))
     )
 
 
 def _files_to_copy_post_revlog_clone(srcrepo):
     """yields files which should be copied to destination after revlogs
     are cloned"""
     for path, kind, st in sorted(srcrepo.store.vfs.readdir(b'', stat=True)):
         # don't copy revlogs as they are already cloned
         if store.revlog_type(path) is not None:
             continue
         # Skip transaction related files.
         if path.startswith(b'undo'):
             continue
         # Only copy regular files.
         if kind != stat.S_IFREG:
             continue
         # Skip other skipped files.
         if path in (b'lock', b'fncache'):
             continue
         # TODO: should we skip cache too?
 
         yield path
 
 
 def _replacestores(currentrepo, upgradedrepo, backupvfs, upgrade_op):
     """Replace the stores after current repository is upgraded
 
     Creates a backup of current repository store at backup path
     Replaces upgraded store files in current repo from upgraded one
 
     Arguments:
       currentrepo: repo object of current repository
       upgradedrepo: repo object of the upgraded data
       backupvfs: vfs object for the backup path
       upgrade_op: upgrade operation object
                   to be used to decide what all is upgraded
     """
     # TODO: don't blindly rename everything in store
     # There can be upgrades where store is not touched at all
     if upgrade_op.backup_store:
         util.rename(currentrepo.spath, backupvfs.join(b'store'))
     else:
         currentrepo.vfs.rmtree(b'store', forcibly=True)
     util.rename(upgradedrepo.spath, currentrepo.spath)
 
 
 def finishdatamigration(ui, srcrepo, dstrepo, requirements):
     """Hook point for extensions to perform additional actions during upgrade.
 
     This function is called after revlogs and store files have been copied but
     before the new store is swapped into the original location.
     """
 
 
 def upgrade(ui, srcrepo, dstrepo, upgrade_op):
     """Do the low-level work of upgrading a repository.
 
     The upgrade is effectively performed as a copy between a source
     repository and a temporary destination repository.
 
     The source repository is unmodified for as long as possible so the
     upgrade can abort at any time without causing loss of service for
     readers and without corrupting the source repository.
     """
     assert srcrepo.currentwlock()
     assert dstrepo.currentwlock()
     backuppath = None
     backupvfs = None
 
     ui.status(
         _(
             b'(it is safe to interrupt this process any time before '
             b'data migration completes)\n'
         )
     )
 
     if upgrade_actions.dirstatev2 in upgrade_op.upgrade_actions:
         ui.status(_(b'upgrading to dirstate-v2 from v1\n'))
         upgrade_dirstate(ui, srcrepo, upgrade_op, b'v1', b'v2')
         upgrade_op.upgrade_actions.remove(upgrade_actions.dirstatev2)
 
     if upgrade_actions.dirstatev2 in upgrade_op.removed_actions:
         ui.status(_(b'downgrading from dirstate-v2 to v1\n'))
         upgrade_dirstate(ui, srcrepo, upgrade_op, b'v2', b'v1')
         upgrade_op.removed_actions.remove(upgrade_actions.dirstatev2)
 
     if upgrade_actions.dirstatetrackedkey in upgrade_op.upgrade_actions:
         ui.status(_(b'create dirstate-tracked-hint file\n'))
         upgrade_tracked_hint(ui, srcrepo, upgrade_op, add=True)
         upgrade_op.upgrade_actions.remove(upgrade_actions.dirstatetrackedkey)
     elif upgrade_actions.dirstatetrackedkey in upgrade_op.removed_actions:
         ui.status(_(b'remove dirstate-tracked-hint file\n'))
         upgrade_tracked_hint(ui, srcrepo, upgrade_op, add=False)
         upgrade_op.removed_actions.remove(upgrade_actions.dirstatetrackedkey)
 
     if not (upgrade_op.upgrade_actions or upgrade_op.removed_actions):
         return
 
     if upgrade_op.requirements_only:
         ui.status(_(b'upgrading repository requirements\n'))
         scmutil.writereporequirements(srcrepo, upgrade_op.new_requirements)
     # if there is only one action and that is persistent nodemap upgrade
     # directly write the nodemap file and update requirements instead of going
     # through the whole cloning process
     elif (
         len(upgrade_op.upgrade_actions) == 1
         and b'persistent-nodemap' in upgrade_op.upgrade_actions_names
         and not upgrade_op.removed_actions
     ):
         ui.status(
             _(b'upgrading repository to use persistent nodemap feature\n')
         )
         with srcrepo.transaction(b'upgrade') as tr:
             unfi = srcrepo.unfiltered()
             cl = unfi.changelog
             nodemap.persist_nodemap(tr, cl, force=True)
             # we want to directly operate on the underlying revlog to force
             # create a nodemap file. This is fine since this is upgrade code
             # and it heavily relies on repository being revlog based
             # hence accessing private attributes can be justified
             nodemap.persist_nodemap(
                 tr, unfi.manifestlog._rootstore._revlog, force=True
             )
         scmutil.writereporequirements(srcrepo, upgrade_op.new_requirements)
     elif (
         len(upgrade_op.removed_actions) == 1
         and [
             x
             for x in upgrade_op.removed_actions
             if x.name == b'persistent-nodemap'
         ]
         and not upgrade_op.upgrade_actions
     ):
         ui.status(
             _(b'downgrading repository to not use persistent nodemap feature\n')
         )
         with srcrepo.transaction(b'upgrade') as tr:
             unfi = srcrepo.unfiltered()
             cl = unfi.changelog
             nodemap.delete_nodemap(tr, srcrepo, cl)
             # check comment 20 lines above for accessing private attributes
             nodemap.delete_nodemap(
                 tr, srcrepo, unfi.manifestlog._rootstore._revlog
             )
         scmutil.writereporequirements(srcrepo, upgrade_op.new_requirements)
     else:
         with dstrepo.transaction(b'upgrade') as tr:
             _clonerevlogs(
                 ui,
                 srcrepo,
                 dstrepo,
                 tr,
                 upgrade_op,
             )
 
         # Now copy other files in the store directory.
         for p in _files_to_copy_post_revlog_clone(srcrepo):
             srcrepo.ui.status(_(b'copying %s\n') % p)
             src = srcrepo.store.rawvfs.join(p)
             dst = dstrepo.store.rawvfs.join(p)
             util.copyfile(src, dst, copystat=True)
 
         finishdatamigration(ui, srcrepo, dstrepo, requirements)
 
         ui.status(_(b'data fully upgraded in a temporary repository\n'))
 
         if upgrade_op.backup_store:
             backuppath = pycompat.mkdtemp(
                 prefix=b'upgradebackup.', dir=srcrepo.path
             )
             backupvfs = vfsmod.vfs(backuppath)
 
             # Make a backup of requires file first, as it is the first to be modified.
             util.copyfile(
                 srcrepo.vfs.join(b'requires'), backupvfs.join(b'requires')
             )
 
         # We install an arbitrary requirement that clients must not support
         # as a mechanism to lock out new clients during the data swap. This is
         # better than allowing a client to continue while the repository is in
         # an inconsistent state.
         ui.status(
             _(
                 b'marking source repository as being upgraded; clients will be '
                 b'unable to read from repository\n'
             )
         )
         scmutil.writereporequirements(
             srcrepo, srcrepo.requirements | {b'upgradeinprogress'}
         )
 
         ui.status(_(b'starting in-place swap of repository data\n'))
         if upgrade_op.backup_store:
             ui.status(
                 _(b'replaced files will be backed up at %s\n') % backuppath
             )
 
         # Now swap in the new store directory. Doing it as a rename should make
         # the operation nearly instantaneous and atomic (at least in well-behaved
         # environments).
         ui.status(_(b'replacing store...\n'))
         tstart = util.timer()
         _replacestores(srcrepo, dstrepo, backupvfs, upgrade_op)
         elapsed = util.timer() - tstart
         ui.status(
             _(
                 b'store replacement complete; repository was inconsistent for '
                 b'%0.1fs\n'
             )
             % elapsed
         )
 
         # We first write the requirements file. Any new requirements will lock
         # out legacy clients.
         ui.status(
             _(
                 b'finalizing requirements file and making repository readable '
                 b'again\n'
             )
         )
         scmutil.writereporequirements(srcrepo, upgrade_op.new_requirements)
 
         if upgrade_op.backup_store:
             # The lock file from the old store won't be removed because nothing has a
             # reference to its new location. So clean it up manually. Alternatively, we
             # could update srcrepo.svfs and other variables to point to the new
             # location. This is simpler.
             assert backupvfs is not None  # help pytype
             backupvfs.unlink(b'store/lock')
 
     return backuppath
 
 
 def upgrade_dirstate(ui, srcrepo, upgrade_op, old, new):
     if upgrade_op.backup_store:
         backuppath = pycompat.mkdtemp(
             prefix=b'upgradebackup.', dir=srcrepo.path
         )
         ui.status(_(b'replaced files will be backed up at %s\n') % backuppath)
         backupvfs = vfsmod.vfs(backuppath)
         util.copyfile(
             srcrepo.vfs.join(b'requires'), backupvfs.join(b'requires')
         )
         try:
             util.copyfile(
                 srcrepo.vfs.join(b'dirstate'), backupvfs.join(b'dirstate')
             )
         except FileNotFoundError:
             # The dirstate does not exist on an empty repo or a repo with no
             # revision checked out
             pass
 
     assert srcrepo.dirstate._use_dirstate_v2 == (old == b'v2')
     use_v2 = new == b'v2'
     if use_v2:
         # Write the requirements *before* upgrading
         scmutil.writereporequirements(srcrepo, upgrade_op.new_requirements)
 
     srcrepo.dirstate._map.preload()
     srcrepo.dirstate._use_dirstate_v2 = use_v2
     srcrepo.dirstate._map._use_dirstate_v2 = use_v2
     srcrepo.dirstate._dirty = True
     try:
         srcrepo.vfs.unlink(b'dirstate')
     except FileNotFoundError:
         # The dirstate does not exist on an empty repo or a repo with no
         # revision checked out
         pass
 
     srcrepo.dirstate.write(None)
     if not use_v2:
         # Remove the v2 requirement *after* downgrading
         scmutil.writereporequirements(srcrepo, upgrade_op.new_requirements)
 
 
 def upgrade_tracked_hint(ui, srcrepo, upgrade_op, add):
     if add:
         srcrepo.dirstate._use_tracked_hint = True
         srcrepo.dirstate._dirty = True
         srcrepo.dirstate._dirty_tracked_set = True
         srcrepo.dirstate.write(None)
     if not add:
         srcrepo.dirstate.delete_tracked_hint()
 
     scmutil.writereporequirements(srcrepo, upgrade_op.new_requirements)