verify: allow suppressing warnings about extra files

The verifier issues warnings when the set of files in .hg/store
doesn't align with the set of files that are advertised via
repo.file(f).files() for all files seen in ctx.files() changelog
traversal.

This logic is reasonable for a default implementation. But some
stores may have extra files whose presence is harmless. Or those
stores may not have the same transaction rollback semantics that
unlink files as other stores.

This commit adds support for disabling the warning for orphaned
files.

The simple store extension has been taught to set this flag.

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

mercurial/verify.py

@@ -1,487 +1,492
 # verify.py - repository integrity checking for Mercurial
 #
 # Copyright 2006, 2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import os
 
 from .i18n import _
 from .node import (
     nullid,
     short,
 )
 
 from . import (
     error,
     pycompat,
     revlog,
     scmutil,
     util,
 )
 
 def verify(repo):
     with repo.lock():
         return verifier(repo).verify()
 
 def _normpath(f):
     # under hg < 2.4, convert didn't sanitize paths properly, so a
     # converted repo may contain repeated slashes
     while '//' in f:
         f = f.replace('//', '/')
     return f
 
 class verifier(object):
     # The match argument is always None in hg core, but e.g. the narrowhg
     # extension will pass in a matcher here.
     def __init__(self, repo, match=None):
         self.repo = repo.unfiltered()
         self.ui = repo.ui
         self.match = match or scmutil.matchall(repo)
         self.badrevs = set()
         self.errors = 0
         self.warnings = 0
         self.havecl = len(repo.changelog) > 0
         self.havemf = len(repo.manifestlog._revlog) > 0
         self.revlogv1 = repo.changelog.version != revlog.REVLOGV0
         self.lrugetctx = util.lrucachefunc(repo.__getitem__)
         self.refersmf = False
         self.fncachewarned = False
         # developer config: verify.skipflags
         self.skipflags = repo.ui.configint('verify', 'skipflags')
+        self.warnorphanstorefiles = True
 
     def warn(self, msg):
         self.ui.warn(msg + "\n")
         self.warnings += 1
 
     def err(self, linkrev, msg, filename=None):
         if linkrev is not None:
             self.badrevs.add(linkrev)
             linkrev = "%d" % linkrev
         else:
             linkrev = '?'
         msg = "%s: %s" % (linkrev, msg)
         if filename:
             msg = "%s@%s" % (filename, msg)
         self.ui.warn(" " + msg + "\n")
         self.errors += 1
 
     def exc(self, linkrev, msg, inst, filename=None):
         fmsg = pycompat.bytestr(inst)
         if not fmsg:
             fmsg = pycompat.byterepr(inst)
         self.err(linkrev, "%s: %s" % (msg, fmsg), filename)
 
     def checklog(self, obj, name, linkrev):
         if not len(obj) and (self.havecl or self.havemf):
             self.err(linkrev, _("empty or missing %s") % name)
             return
 
         d = obj.checksize()
         if d[0]:
             self.err(None, _("data length off by %d bytes") % d[0], name)
         if d[1]:
             self.err(None, _("index contains %d extra bytes") % d[1], name)
 
         if obj.version != revlog.REVLOGV0:
             if not self.revlogv1:
                 self.warn(_("warning: `%s' uses revlog format 1") % name)
         elif self.revlogv1:
             self.warn(_("warning: `%s' uses revlog format 0") % name)
 
     def checkentry(self, obj, i, node, seen, linkrevs, f):
         lr = obj.linkrev(obj.rev(node))
         if lr < 0 or (self.havecl and lr not in linkrevs):
             if lr < 0 or lr >= len(self.repo.changelog):
                 msg = _("rev %d points to nonexistent changeset %d")
             else:
                 msg = _("rev %d points to unexpected changeset %d")
             self.err(None, msg % (i, lr), f)
             if linkrevs:
                 if f and len(linkrevs) > 1:
                     try:
                         # attempt to filter down to real linkrevs
                         linkrevs = [l for l in linkrevs
                                     if self.lrugetctx(l)[f].filenode() == node]
                     except Exception:
                         pass
                 self.warn(_(" (expected %s)") % " ".join
                           (map(pycompat.bytestr, linkrevs)))
             lr = None # can't be trusted
 
         try:
             p1, p2 = obj.parents(node)
             if p1 not in seen and p1 != nullid:
                 self.err(lr, _("unknown parent 1 %s of %s") %
                     (short(p1), short(node)), f)
             if p2 not in seen and p2 != nullid:
                 self.err(lr, _("unknown parent 2 %s of %s") %
                     (short(p2), short(node)), f)
         except Exception as inst:
             self.exc(lr, _("checking parents of %s") % short(node), inst, f)
 
         if node in seen:
             self.err(lr, _("duplicate revision %d (%d)") % (i, seen[node]), f)
         seen[node] = i
         return lr
 
     def verify(self):
         repo = self.repo
 
         ui = repo.ui
 
         if not repo.url().startswith('file:'):
             raise error.Abort(_("cannot verify bundle or remote repos"))
 
         if os.path.exists(repo.sjoin("journal")):
             ui.warn(_("abandoned transaction found - run hg recover\n"))
 
         if ui.verbose or not self.revlogv1:
             ui.status(_("repository uses revlog format %d\n") %
                            (self.revlogv1 and 1 or 0))
 
         mflinkrevs, filelinkrevs = self._verifychangelog()
 
         filenodes = self._verifymanifest(mflinkrevs)
         del mflinkrevs
 
         self._crosscheckfiles(filelinkrevs, filenodes)
 
         totalfiles, filerevisions = self._verifyfiles(filenodes, filelinkrevs)
 
         ui.status(_("%d files, %d changesets, %d total revisions\n") %
                        (totalfiles, len(repo.changelog), filerevisions))
         if self.warnings:
             ui.warn(_("%d warnings encountered!\n") % self.warnings)
         if self.fncachewarned:
             ui.warn(_('hint: run "hg debugrebuildfncache" to recover from '
                       'corrupt fncache\n'))
         if self.errors:
             ui.warn(_("%d integrity errors encountered!\n") % self.errors)
             if self.badrevs:
                 ui.warn(_("(first damaged changeset appears to be %d)\n")
                         % min(self.badrevs))
             return 1
 
     def _verifychangelog(self):
         ui = self.ui
         repo = self.repo
         match = self.match
         cl = repo.changelog
 
         ui.status(_("checking changesets\n"))
         mflinkrevs = {}
         filelinkrevs = {}
         seen = {}
         self.checklog(cl, "changelog", 0)
         total = len(repo)
         for i in repo:
             ui.progress(_('checking'), i, total=total, unit=_('changesets'))
             n = cl.node(i)
             self.checkentry(cl, i, n, seen, [i], "changelog")
 
             try:
                 changes = cl.read(n)
                 if changes[0] != nullid:
                     mflinkrevs.setdefault(changes[0], []).append(i)
                     self.refersmf = True
                 for f in changes[3]:
                     if match(f):
                         filelinkrevs.setdefault(_normpath(f), []).append(i)
             except Exception as inst:
                 self.refersmf = True
                 self.exc(i, _("unpacking changeset %s") % short(n), inst)
         ui.progress(_('checking'), None)
         return mflinkrevs, filelinkrevs
 
     def _verifymanifest(self, mflinkrevs, dir="", storefiles=None,
                         progress=None):
         repo = self.repo
         ui = self.ui
         match = self.match
         mfl = self.repo.manifestlog
         mf = mfl._revlog.dirlog(dir)
 
         if not dir:
             self.ui.status(_("checking manifests\n"))
 
         filenodes = {}
         subdirnodes = {}
         seen = {}
         label = "manifest"
         if dir:
             label = dir
             revlogfiles = mf.files()
             storefiles.difference_update(revlogfiles)
             if progress: # should be true since we're in a subdirectory
                 progress()
         if self.refersmf:
             # Do not check manifest if there are only changelog entries with
             # null manifests.
             self.checklog(mf, label, 0)
         total = len(mf)
         for i in mf:
             if not dir:
                 ui.progress(_('checking'), i, total=total, unit=_('manifests'))
             n = mf.node(i)
             lr = self.checkentry(mf, i, n, seen, mflinkrevs.get(n, []), label)
             if n in mflinkrevs:
                 del mflinkrevs[n]
             elif dir:
                 self.err(lr, _("%s not in parent-directory manifest") %
                          short(n), label)
             else:
                 self.err(lr, _("%s not in changesets") % short(n), label)
 
             try:
                 mfdelta = mfl.get(dir, n).readdelta(shallow=True)
                 for f, fn, fl in mfdelta.iterentries():
                     if not f:
                         self.err(lr, _("entry without name in manifest"))
                     elif f == "/dev/null":  # ignore this in very old repos
                         continue
                     fullpath = dir + _normpath(f)
                     if fl == 't':
                         if not match.visitdir(fullpath):
                             continue
                         subdirnodes.setdefault(fullpath + '/', {}).setdefault(
                             fn, []).append(lr)
                     else:
                         if not match(fullpath):
                             continue
                         filenodes.setdefault(fullpath, {}).setdefault(fn, lr)
             except Exception as inst:
                 self.exc(lr, _("reading delta %s") % short(n), inst, label)
         if not dir:
             ui.progress(_('checking'), None)
 
         if self.havemf:
             for c, m in sorted([(c, m) for m in mflinkrevs
                         for c in mflinkrevs[m]]):
                 if dir:
                     self.err(c, _("parent-directory manifest refers to unknown "
                                   "revision %s") % short(m), label)
                 else:
                     self.err(c, _("changeset refers to unknown revision %s") %
                              short(m), label)
 
         if not dir and subdirnodes:
             self.ui.status(_("checking directory manifests\n"))
             storefiles = set()
             subdirs = set()
             revlogv1 = self.revlogv1
             for f, f2, size in repo.store.datafiles():
                 if not f:
                     self.err(None, _("cannot decode filename '%s'") % f2)
                 elif (size > 0 or not revlogv1) and f.startswith('meta/'):
                     storefiles.add(_normpath(f))
                     subdirs.add(os.path.dirname(f))
             subdircount = len(subdirs)
             currentsubdir = [0]
             def progress():
                 currentsubdir[0] += 1
                 ui.progress(_('checking'), currentsubdir[0], total=subdircount,
                             unit=_('manifests'))
 
         for subdir, linkrevs in subdirnodes.iteritems():
             subdirfilenodes = self._verifymanifest(linkrevs, subdir, storefiles,
                                                    progress)
             for f, onefilenodes in subdirfilenodes.iteritems():
                 filenodes.setdefault(f, {}).update(onefilenodes)
 
         if not dir and subdirnodes:
             ui.progress(_('checking'), None)
+            if self.warnorphanstorefiles:
             for f in sorted(storefiles):
                 self.warn(_("warning: orphan data file '%s'") % f)
 
         return filenodes
 
     def _crosscheckfiles(self, filelinkrevs, filenodes):
         repo = self.repo
         ui = self.ui
         ui.status(_("crosschecking files in changesets and manifests\n"))
 
         total = len(filelinkrevs) + len(filenodes)
         count = 0
         if self.havemf:
             for f in sorted(filelinkrevs):
                 count += 1
                 ui.progress(_('crosschecking'), count, total=total)
                 if f not in filenodes:
                     lr = filelinkrevs[f][0]
                     self.err(lr, _("in changeset but not in manifest"), f)
 
         if self.havecl:
             for f in sorted(filenodes):
                 count += 1
                 ui.progress(_('crosschecking'), count, total=total)
                 if f not in filelinkrevs:
                     try:
                         fl = repo.file(f)
                         lr = min([fl.linkrev(fl.rev(n)) for n in filenodes[f]])
                     except Exception:
                         lr = None
                     self.err(lr, _("in manifest but not in changeset"), f)
 
         ui.progress(_('crosschecking'), None)
 
     def _verifyfiles(self, filenodes, filelinkrevs):
         repo = self.repo
         ui = self.ui
         lrugetctx = self.lrugetctx
         revlogv1 = self.revlogv1
         havemf = self.havemf
         ui.status(_("checking files\n"))
 
         storefiles = set()
         for f, f2, size in repo.store.datafiles():
             if not f:
                 self.err(None, _("cannot decode filename '%s'") % f2)
             elif (size > 0 or not revlogv1) and f.startswith('data/'):
                 storefiles.add(_normpath(f))
 
         files = sorted(set(filenodes) | set(filelinkrevs))
         total = len(files)
         revisions = 0
         for i, f in enumerate(files):
             ui.progress(_('checking'), i, item=f, total=total, unit=_('files'))
             try:
                 linkrevs = filelinkrevs[f]
             except KeyError:
                 # in manifest but not in changelog
                 linkrevs = []
 
             if linkrevs:
                 lr = linkrevs[0]
             else:
                 lr = None
 
             try:
                 fl = repo.file(f)
             except error.RevlogError as e:
                 self.err(lr, _("broken revlog! (%s)") % e, f)
                 continue
 
             for ff in fl.files():
                 try:
                     storefiles.remove(ff)
                 except KeyError:
-                    self.warn(_(" warning: revlog '%s' not in fncache!") % ff)
+                    if self.warnorphanstorefiles:
+                        self.warn(_(" warning: revlog '%s' not in fncache!") %
+                                  ff)
                     self.fncachewarned = True
 
             self.checklog(fl, f, lr)
             seen = {}
             rp = None
             for i in fl:
                 revisions += 1
                 n = fl.node(i)
                 lr = self.checkentry(fl, i, n, seen, linkrevs, f)
                 if f in filenodes:
                     if havemf and n not in filenodes[f]:
                         self.err(lr, _("%s not in manifests") % (short(n)), f)
                     else:
                         del filenodes[f][n]
 
                 # Verify contents. 4 cases to care about:
                 #
                 #   common: the most common case
                 #   rename: with a rename
                 #   meta: file content starts with b'\1\n', the metadata
                 #         header defined in filelog.py, but without a rename
                 #   ext: content stored externally
                 #
                 # More formally, their differences are shown below:
                 #
                 #                       | common | rename | meta  | ext
                 #  -------------------------------------------------------
                 #   flags()             | 0      | 0      | 0     | not 0
                 #   renamed()           | False  | True   | False | ?
                 #   rawtext[0:2]=='\1\n'| False  | True   | True  | ?
                 #
                 # "rawtext" means the raw text stored in revlog data, which
                 # could be retrieved by "revision(rev, raw=True)". "text"
                 # mentioned below is "revision(rev, raw=False)".
                 #
                 # There are 3 different lengths stored physically:
                 #  1. L1: rawsize, stored in revlog index
                 #  2. L2: len(rawtext), stored in revlog data
                 #  3. L3: len(text), stored in revlog data if flags==0, or
                 #     possibly somewhere else if flags!=0
                 #
                 # L1 should be equal to L2. L3 could be different from them.
                 # "text" may or may not affect commit hash depending on flag
                 # processors (see revlog.addflagprocessor).
                 #
                 #              | common  | rename | meta  | ext
                 # -------------------------------------------------
                 #    rawsize() | L1      | L1     | L1    | L1
                 #       size() | L1      | L2-LM  | L1(*) | L1 (?)
                 # len(rawtext) | L2      | L2     | L2    | L2
                 #    len(text) | L2      | L2     | L2    | L3
                 #  len(read()) | L2      | L2-LM  | L2-LM | L3 (?)
                 #
                 # LM:  length of metadata, depending on rawtext
                 # (*): not ideal, see comment in filelog.size
                 # (?): could be "- len(meta)" if the resolved content has
                 #      rename metadata
                 #
                 # Checks needed to be done:
                 #  1. length check: L1 == L2, in all cases.
                 #  2. hash check: depending on flag processor, we may need to
                 #     use either "text" (external), or "rawtext" (in revlog).
                 try:
                     skipflags = self.skipflags
                     if skipflags:
                         skipflags &= fl.flags(i)
                     if not skipflags:
                         fl.read(n) # side effect: read content and do checkhash
                         rp = fl.renamed(n)
                     # the "L1 == L2" check
                     l1 = fl.rawsize(i)
                     l2 = len(fl.revision(n, raw=True))
                     if l1 != l2:
                         self.err(lr, _("unpacked size is %s, %s expected") %
                                  (l2, l1), f)
                 except error.CensoredNodeError:
                     # experimental config: censor.policy
                     if ui.config("censor", "policy") == "abort":
                         self.err(lr, _("censored file data"), f)
                 except Exception as inst:
                     self.exc(lr, _("unpacking %s") % short(n), inst, f)
 
                 # check renames
                 try:
                     if rp:
                         if lr is not None and ui.verbose:
                             ctx = lrugetctx(lr)
                             if not any(rp[0] in pctx for pctx in ctx.parents()):
                                 self.warn(_("warning: copy source of '%s' not"
                                             " in parents of %s") % (f, ctx))
                         fl2 = repo.file(rp[0])
                         if not len(fl2):
                             self.err(lr, _("empty or missing copy source "
                                      "revlog %s:%s") % (rp[0], short(rp[1])), f)
                         elif rp[1] == nullid:
                             ui.note(_("warning: %s@%s: copy source"
                                       " revision is nullid %s:%s\n")
                                 % (f, lr, rp[0], short(rp[1])))
                         else:
                             fl2.rev(rp[1])
                 except Exception as inst:
                     self.exc(lr, _("checking rename of %s") % short(n), inst, f)
 
             # cross-check
             if f in filenodes:
                 fns = [(v, k) for k, v in filenodes[f].iteritems()]
                 for lr, node in sorted(fns):
                     self.err(lr, _("manifest refers to unknown revision %s") %
                              short(node), f)
         ui.progress(_('checking'), None)
 
+        if self.warnorphanstorefiles:
         for f in sorted(storefiles):
             self.warn(_("warning: orphan data file '%s'") % f)
 
         return len(files), revisions

tests/simplestorerepo.py

@@ -1,664 +1,673
 # simplestorerepo.py - Extension that swaps in alternate repository storage.
 #
 # Copyright 2018 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 # To use this with the test suite:
 #
 #   $ HGREPOFEATURES="simplestore" ./run-tests.py \
 #       --extra-config-opt extensions.simplestore=`pwd`/simplestorerepo.py
 
 from __future__ import absolute_import
 
 import stat
 
 from mercurial.i18n import _
 from mercurial.node import (
     bin,
     hex,
     nullid,
     nullrev,
 )
 from mercurial.thirdparty import (
     cbor,
 )
 from mercurial import (
     ancestor,
     bundlerepo,
     error,
     extensions,
     filelog,
     localrepo,
     mdiff,
     pycompat,
     revlog,
     store,
+    verify,
 )
 
 # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
 testedwith = 'ships-with-hg-core'
 
 REQUIREMENT = 'testonly-simplestore'
 
 def validatenode(node):
     if isinstance(node, int):
         raise ValueError('expected node; got int')
 
     if len(node) != 20:
         raise ValueError('expected 20 byte node')
 
 def validaterev(rev):
     if not isinstance(rev, int):
         raise ValueError('expected int')
 
 class filestorage(object):
     """Implements storage for a tracked path.
 
     Data is stored in the VFS in a directory corresponding to the tracked
     path.
 
     Index data is stored in an ``index`` file using CBOR.
 
     Fulltext data is stored in files having names of the node.
     """
 
     def __init__(self, svfs, path):
         self._svfs = svfs
         self._path = path
 
         self._storepath = b'/'.join([b'data', path])
         self._indexpath = b'/'.join([self._storepath, b'index'])
 
         indexdata = self._svfs.tryread(self._indexpath)
         if indexdata:
             indexdata = cbor.loads(indexdata)
 
         self._indexdata = indexdata or []
         self._indexbynode = {}
         self._indexbyrev = {}
         self.index = []
         self._refreshindex()
 
         # This is used by changegroup code :/
         self._generaldelta = True
         self.storedeltachains = False
 
         self.version = 1
 
     def _refreshindex(self):
         self._indexbynode.clear()
         self._indexbyrev.clear()
         self.index = []
 
         for i, entry in enumerate(self._indexdata):
             self._indexbynode[entry[b'node']] = entry
             self._indexbyrev[i] = entry
 
         self._indexbynode[nullid] = {
             b'node': nullid,
             b'p1': nullid,
             b'p2': nullid,
             b'linkrev': nullrev,
             b'flags': 0,
         }
 
         self._indexbyrev[nullrev] = {
             b'node': nullid,
             b'p1': nullid,
             b'p2': nullid,
             b'linkrev': nullrev,
             b'flags': 0,
         }
 
         for i, entry in enumerate(self._indexdata):
             p1rev, p2rev = self.parentrevs(self.rev(entry[b'node']))
 
             # start, length, rawsize, chainbase, linkrev, p1, p2, node
             self.index.append((0, 0, 0, -1, entry[b'linkrev'], p1rev, p2rev,
                                entry[b'node']))
 
         self.index.append((0, 0, 0, -1, -1, -1, -1, nullid))
 
     def __len__(self):
         return len(self._indexdata)
 
     def __iter__(self):
         return iter(range(len(self)))
 
     def revs(self, start=0, stop=None):
         step = 1
         if stop is not None:
             if start > stop:
                 step = -1
 
             stop += step
         else:
             stop = len(self)
 
         return range(start, stop, step)
 
     def parents(self, node):
         validatenode(node)
 
         if node not in self._indexbynode:
             raise KeyError('unknown node')
 
         entry = self._indexbynode[node]
 
         return entry[b'p1'], entry[b'p2']
 
     def parentrevs(self, rev):
         p1, p2 = self.parents(self._indexbyrev[rev][b'node'])
         return self.rev(p1), self.rev(p2)
 
     def rev(self, node):
         validatenode(node)
 
         try:
             self._indexbynode[node]
         except KeyError:
             raise error.LookupError(node, self._indexpath, _('no node'))
 
         for rev, entry in self._indexbyrev.items():
             if entry[b'node'] == node:
                 return rev
 
         raise error.ProgrammingError('this should not occur')
 
     def node(self, rev):
         validaterev(rev)
 
         return self._indexbyrev[rev][b'node']
 
     def lookup(self, node):
         if isinstance(node, int):
             return self.node(node)
 
         if len(node) == 20:
             self.rev(node)
             return node
 
         try:
             rev = int(node)
             if '%d' % rev != node:
                 raise ValueError
 
             if rev < 0:
                 rev = len(self) + rev
             if rev < 0 or rev >= len(self):
                 raise ValueError
 
             return self.node(rev)
         except (ValueError, OverflowError):
             pass
 
         if len(node) == 40:
             try:
                 rawnode = bin(node)
                 self.rev(rawnode)
                 return rawnode
             except TypeError:
                 pass
 
         raise error.LookupError(node, self._path, _('invalid lookup input'))
 
     def linkrev(self, rev):
         validaterev(rev)
 
         return self._indexbyrev[rev][b'linkrev']
 
     def flags(self, rev):
         validaterev(rev)
 
         return self._indexbyrev[rev][b'flags']
 
     def deltaparent(self, rev):
         validaterev(rev)
 
         p1node = self.parents(self.node(rev))[0]
         return self.rev(p1node)
 
     def candelta(self, baserev, rev):
         validaterev(baserev)
         validaterev(rev)
 
         if ((self.flags(baserev) & revlog.REVIDX_RAWTEXT_CHANGING_FLAGS)
             or (self.flags(rev) & revlog.REVIDX_RAWTEXT_CHANGING_FLAGS)):
             return False
 
         return True
 
     def rawsize(self, rev):
         validaterev(rev)
         node = self.node(rev)
         return len(self.revision(node, raw=True))
 
     def _processflags(self, text, flags, operation, raw=False):
         if flags == 0:
             return text, True
 
         validatehash = True
         # Depending on the operation (read or write), the order might be
         # reversed due to non-commutative transforms.
         orderedflags = revlog.REVIDX_FLAGS_ORDER
         if operation == 'write':
             orderedflags = reversed(orderedflags)
 
         for flag in orderedflags:
             # If a flagprocessor has been registered for a known flag, apply the
             # related operation transform and update result tuple.
             if flag & flags:
                 vhash = True
 
                 if flag not in revlog._flagprocessors:
                     message = _("missing processor for flag '%#x'") % (flag)
                     raise revlog.RevlogError(message)
 
                 processor = revlog._flagprocessors[flag]
                 if processor is not None:
                     readtransform, writetransform, rawtransform = processor
 
                     if raw:
                         vhash = rawtransform(self, text)
                     elif operation == 'read':
                         text, vhash = readtransform(self, text)
                     else:  # write operation
                         text, vhash = writetransform(self, text)
                 validatehash = validatehash and vhash
 
         return text, validatehash
 
     def checkhash(self, text, node, p1=None, p2=None, rev=None):
         if p1 is None and p2 is None:
             p1, p2 = self.parents(node)
         if node != revlog.hash(text, p1, p2):
             raise error.RevlogError(_("integrity check failed on %s") %
                 self._path)
 
     def revision(self, node, raw=False):
         validatenode(node)
 
         if node == nullid:
             return b''
 
         rev = self.rev(node)
         flags = self.flags(rev)
 
         path = b'/'.join([self._storepath, hex(node)])
         rawtext = self._svfs.read(path)
 
         text, validatehash = self._processflags(rawtext, flags, 'read', raw=raw)
         if validatehash:
             self.checkhash(text, node, rev=rev)
 
         return text
 
     def read(self, node):
         validatenode(node)
 
         revision = self.revision(node)
 
         if not revision.startswith(b'\1\n'):
             return revision
 
         start = revision.index(b'\1\n', 2)
         return revision[start + 2:]
 
     def renamed(self, node):
         validatenode(node)
 
         if self.parents(node)[0] != nullid:
             return False
 
         fulltext = self.revision(node)
         m = filelog.parsemeta(fulltext)[0]
 
         if m and 'copy' in m:
             return m['copy'], bin(m['copyrev'])
 
         return False
 
     def cmp(self, node, text):
         validatenode(node)
 
         t = text
 
         if text.startswith(b'\1\n'):
             t = b'\1\n\1\n' + text
 
         p1, p2 = self.parents(node)
 
         if revlog.hash(t, p1, p2) == node:
             return False
 
         if self.iscensored(self.rev(node)):
             return text != b''
 
         if self.renamed(node):
             t2 = self.read(node)
             return t2 != text
 
         return True
 
     def size(self, rev):
         validaterev(rev)
 
         node = self._indexbyrev[rev][b'node']
 
         if self.renamed(node):
             return len(self.read(node))
 
         if self.iscensored(rev):
             return 0
 
         return len(self.revision(node))
 
     def iscensored(self, rev):
         validaterev(rev)
 
         return self.flags(rev) & revlog.REVIDX_ISCENSORED
 
     def commonancestorsheads(self, a, b):
         validatenode(a)
         validatenode(b)
 
         a = self.rev(a)
         b = self.rev(b)
 
         ancestors = ancestor.commonancestorsheads(self.parentrevs, a, b)
         return pycompat.maplist(self.node, ancestors)
 
     def descendants(self, revs):
         # This is a copy of revlog.descendants()
         first = min(revs)
         if first == nullrev:
             for i in self:
                 yield i
             return
 
         seen = set(revs)
         for i in self.revs(start=first + 1):
             for x in self.parentrevs(i):
                 if x != nullrev and x in seen:
                     seen.add(i)
                     yield i
                     break
 
     # Required by verify.
     def files(self):
         entries = self._svfs.listdir(self._storepath)
 
         # Strip out undo.backup.* files created as part of transaction
         # recording.
         entries = [f for f in entries if not f.startswith('undo.backup.')]
 
         return [b'/'.join((self._storepath, f)) for f in entries]
 
     # Required by verify.
     def checksize(self):
         return 0, 0
 
     def add(self, text, meta, transaction, linkrev, p1, p2):
         if meta or text.startswith(b'\1\n'):
             text = filelog.packmeta(meta, text)
 
         return self.addrevision(text, transaction, linkrev, p1, p2)
 
     def addrevision(self, text, transaction, linkrev, p1, p2, node=None,
                     flags=0):
         validatenode(p1)
         validatenode(p2)
 
         if flags:
             node = node or revlog.hash(text, p1, p2)
 
         rawtext, validatehash = self._processflags(text, flags, 'write')
 
         node = node or revlog.hash(text, p1, p2)
 
         if node in self._indexbynode:
             return node
 
         if validatehash:
             self.checkhash(rawtext, node, p1=p1, p2=p2)
 
         path = b'/'.join([self._storepath, hex(node)])
 
         self._svfs.write(path, text)
 
         self._indexdata.append({
             b'node': node,
             b'p1': p1,
             b'p2': p2,
             b'linkrev': linkrev,
             b'flags': flags,
         })
 
         self._reflectindexupdate()
 
         return node
 
     def _reflectindexupdate(self):
         self._refreshindex()
         self._svfs.write(self._indexpath, cbor.dumps(self._indexdata))
 
     def addgroup(self, deltas, linkmapper, transaction, addrevisioncb=None):
         nodes = []
 
         transaction.addbackup(self._indexpath)
 
         for node, p1, p2, linknode, deltabase, delta, flags in deltas:
             linkrev = linkmapper(linknode)
 
             nodes.append(node)
 
             if node in self._indexbynode:
                 continue
 
             # Need to resolve the fulltext from the delta base.
             if deltabase == nullid:
                 text = mdiff.patch(b'', delta)
             else:
                 text = mdiff.patch(self.revision(deltabase), delta)
 
             self.addrevision(text, transaction, linkrev, p1, p2, flags)
 
             if addrevisioncb:
                 addrevisioncb(self, node)
 
         return nodes
 
     def revdiff(self, rev1, rev2):
         validaterev(rev1)
         validaterev(rev2)
 
         node1 = self.node(rev1)
         node2 = self.node(rev2)
 
         return mdiff.textdiff(self.revision(node1, raw=True),
                               self.revision(node2, raw=True))
 
     def headrevs(self):
         # Assume all revisions are heads by default.
         revishead = {rev: True for rev in self._indexbyrev}
 
         for rev, entry in self._indexbyrev.items():
             # Unset head flag for all seen parents.
             revishead[self.rev(entry[b'p1'])] = False
             revishead[self.rev(entry[b'p2'])] = False
 
         return [rev for rev, ishead in sorted(revishead.items())
                 if ishead]
 
     def heads(self, start=None, stop=None):
         # This is copied from revlog.py.
         if start is None and stop is None:
             if not len(self):
                 return [nullid]
             return [self.node(r) for r in self.headrevs()]
 
         if start is None:
             start = nullid
         if stop is None:
             stop = []
         stoprevs = set([self.rev(n) for n in stop])
         startrev = self.rev(start)
         reachable = {startrev}
         heads = {startrev}
 
         parentrevs = self.parentrevs
         for r in self.revs(start=startrev + 1):
             for p in parentrevs(r):
                 if p in reachable:
                     if r not in stoprevs:
                         reachable.add(r)
                     heads.add(r)
                 if p in heads and p not in stoprevs:
                     heads.remove(p)
 
         return [self.node(r) for r in heads]
 
     def children(self, node):
         validatenode(node)
 
         # This is a copy of revlog.children().
         c = []
         p = self.rev(node)
         for r in self.revs(start=p + 1):
             prevs = [pr for pr in self.parentrevs(r) if pr != nullrev]
             if prevs:
                 for pr in prevs:
                     if pr == p:
                         c.append(self.node(r))
             elif p == nullrev:
                 c.append(self.node(r))
         return c
 
     def getstrippoint(self, minlink):
 
         # This is largely a copy of revlog.getstrippoint().
         brokenrevs = set()
         strippoint = len(self)
 
         heads = {}
         futurelargelinkrevs = set()
         for head in self.headrevs():
             headlinkrev = self.linkrev(head)
             heads[head] = headlinkrev
             if headlinkrev >= minlink:
                 futurelargelinkrevs.add(headlinkrev)
 
         # This algorithm involves walking down the rev graph, starting at the
         # heads. Since the revs are topologically sorted according to linkrev,
         # once all head linkrevs are below the minlink, we know there are
         # no more revs that could have a linkrev greater than minlink.
         # So we can stop walking.
         while futurelargelinkrevs:
             strippoint -= 1
             linkrev = heads.pop(strippoint)
 
             if linkrev < minlink:
                 brokenrevs.add(strippoint)
             else:
                 futurelargelinkrevs.remove(linkrev)
 
             for p in self.parentrevs(strippoint):
                 if p != nullrev:
                     plinkrev = self.linkrev(p)
                     heads[p] = plinkrev
                     if plinkrev >= minlink:
                         futurelargelinkrevs.add(plinkrev)
 
         return strippoint, brokenrevs
 
     def strip(self, minlink, transaction):
         if not len(self):
             return
 
         rev, _ignored = self.getstrippoint(minlink)
         if rev == len(self):
             return
 
         # Purge index data starting at the requested revision.
         self._indexdata[rev:] = []
         self._reflectindexupdate()
 
 def issimplestorefile(f, kind, st):
     if kind != stat.S_IFREG:
         return False
 
     if store.isrevlog(f, kind, st):
         return False
 
     # Ignore transaction undo files.
     if f.startswith('undo.'):
         return False
 
     # Otherwise assume it belongs to the simple store.
     return True
 
 class simplestore(store.encodedstore):
     def datafiles(self):
         for x in super(simplestore, self).datafiles():
             yield x
 
         # Supplement with non-revlog files.
         extrafiles = self._walk('data', True, filefilter=issimplestorefile)
 
         for unencoded, encoded, size in extrafiles:
             try:
                 unencoded = store.decodefilename(unencoded)
             except KeyError:
                 unencoded = None
 
             yield unencoded, encoded, size
 
 def reposetup(ui, repo):
     if not repo.local():
         return
 
     if isinstance(repo, bundlerepo.bundlerepository):
         raise error.Abort(_('cannot use simple store with bundlerepo'))
 
     class simplestorerepo(repo.__class__):
         def file(self, f):
             return filestorage(self.svfs, f)
 
     repo.__class__ = simplestorerepo
 
 def featuresetup(ui, supported):
     supported.add(REQUIREMENT)
 
 def newreporequirements(orig, repo):
     """Modifies default requirements for new repos to use the simple store."""
     requirements = orig(repo)
 
     # These requirements are only used to affect creation of the store
     # object. We have our own store. So we can remove them.
     # TODO do this once we feel like taking the test hit.
     #if 'fncache' in requirements:
     #    requirements.remove('fncache')
     #if 'dotencode' in requirements:
     #    requirements.remove('dotencode')
 
     requirements.add(REQUIREMENT)
 
     return requirements
 
 def makestore(orig, requirements, path, vfstype):
     if REQUIREMENT not in requirements:
         return orig(requirements, path, vfstype)
 
     return simplestore(path, vfstype)
 
+def verifierinit(orig, self, *args, **kwargs):
+    orig(self, *args, **kwargs)
+
+    # We don't care that files in the store don't align with what is
+    # advertised. So suppress these warnings.
+    self.warnorphanstorefiles = False
+
 def extsetup(ui):
     localrepo.featuresetupfuncs.add(featuresetup)
 
     extensions.wrapfunction(localrepo, 'newreporequirements',
                             newreporequirements)
     extensions.wrapfunction(store, 'store', makestore)
+    extensions.wrapfunction(verify.verifier, '__init__', verifierinit)