filelog: add a hasnode() method (API)

Missing in the file storage interface is the ability to query whether
a specified value is a known node.

This commit defines that interface member and implements it on the
revlog and sqlite file stores.

Storage unit tests have been added.

The revlog implementation is a bit more complicated because index lookups
don't consistently raise the same exception. For SQLite, we can simply look
for a key in a dict.

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

hgext/sqlitestore.py

@@ -1,1113 +1,1119
 # sqlitestore.py - Storage backend that uses SQLite
 #
 # 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.
 
 """store repository data in SQLite (EXPERIMENTAL)
 
 The sqlitestore extension enables the storage of repository data in SQLite.
 
 This extension is HIGHLY EXPERIMENTAL. There are NO BACKWARDS COMPATIBILITY
 GUARANTEES. This means that repositories created with this extension may
 only be usable with the exact version of this extension/Mercurial that was
 used. The extension attempts to enforce this in order to prevent repository
 corruption.
 
 In addition, several features are not yet supported or have known bugs:
 
 * Only some data is stored in SQLite. Changeset, manifest, and other repository
   data is not yet stored in SQLite.
 * Transactions are not robust. If the process is aborted at the right time
   during transaction close/rollback, the repository could be in an inconsistent
   state. This problem will diminish once all repository data is tracked by
   SQLite.
 * Bundle repositories do not work (the ability to use e.g.
   `hg -R <bundle-file> log` to automatically overlay a bundle on top of the
   existing repository).
 * Various other features don't work.
 
 This extension should work for basic clone/pull, update, and commit workflows.
 Some history rewriting operations may fail due to lack of support for bundle
 repositories.
 
 To use, activate the extension and set the ``storage.new-repo-backend`` config
 option to ``sqlite`` to enable new repositories to use SQLite for storage.
 """
 
 # To run the test suite with repos using SQLite by default, execute the
 # following:
 #
 # HGREPOFEATURES="sqlitestore" run-tests.py \
 #     --extra-config-opt extensions.sqlitestore= \
 #     --extra-config-opt storage.new-repo-backend=sqlite
 
 from __future__ import absolute_import
 
 import hashlib
 import sqlite3
 import struct
 import threading
 import zlib
 
 from mercurial.i18n import _
 from mercurial.node import (
     nullid,
     nullrev,
     short,
 )
 from mercurial.thirdparty import (
     attr,
 )
 from mercurial import (
     ancestor,
     dagop,
     error,
     extensions,
     localrepo,
     mdiff,
     pycompat,
     registrar,
     repository,
     util,
     verify,
 )
 from mercurial.utils import (
     interfaceutil,
     storageutil,
 )
 
 try:
     from mercurial import zstd
     zstd.__version__
 except ImportError:
     zstd = None
 
 configtable = {}
 configitem = registrar.configitem(configtable)
 
 # experimental config: storage.sqlite.compression
 configitem('storage', 'sqlite.compression',
            default='zstd' if zstd else 'zlib')
 
 # 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 = b'exp-sqlite-001'
 REQUIREMENT_ZSTD = b'exp-sqlite-comp-001=zstd'
 REQUIREMENT_ZLIB = b'exp-sqlite-comp-001=zlib'
 REQUIREMENT_NONE = b'exp-sqlite-comp-001=none'
 
 CURRENT_SCHEMA_VERSION = 1
 
 COMPRESSION_NONE = 1
 COMPRESSION_ZSTD = 2
 COMPRESSION_ZLIB = 3
 
 FLAG_CENSORED = 1
 
 CREATE_SCHEMA = [
     # Deltas are stored as content-indexed blobs.
     # compression column holds COMPRESSION_* constant for how the
     # delta is encoded.
 
     r'CREATE TABLE delta ('
     r'    id INTEGER PRIMARY KEY, '
     r'    compression INTEGER NOT NULL, '
     r'    hash BLOB UNIQUE ON CONFLICT ABORT, '
     r'    delta BLOB NOT NULL '
     r')',
 
     # Tracked paths are denormalized to integers to avoid redundant
     # storage of the path name.
     r'CREATE TABLE filepath ('
     r'    id INTEGER PRIMARY KEY, '
     r'    path BLOB NOT NULL '
     r')',
 
     r'CREATE UNIQUE INDEX filepath_path '
     r'    ON filepath (path)',
 
     # We have a single table for all file revision data.
     # Each file revision is uniquely described by a (path, rev) and
     # (path, node).
     #
     # Revision data is stored as a pointer to the delta producing this
     # revision and the file revision whose delta should be applied before
     # that one. One can reconstruct the delta chain by recursively following
     # the delta base revision pointers until one encounters NULL.
     #
     # flags column holds bitwise integer flags controlling storage options.
     # These flags are defined by the FLAG_* constants.
     r'CREATE TABLE fileindex ('
     r'    id INTEGER PRIMARY KEY, '
     r'    pathid INTEGER REFERENCES filepath(id), '
     r'    revnum INTEGER NOT NULL, '
     r'    p1rev INTEGER NOT NULL, '
     r'    p2rev INTEGER NOT NULL, '
     r'    linkrev INTEGER NOT NULL, '
     r'    flags INTEGER NOT NULL, '
     r'    deltaid INTEGER REFERENCES delta(id), '
     r'    deltabaseid INTEGER REFERENCES fileindex(id), '
     r'    node BLOB NOT NULL '
     r')',
 
     r'CREATE UNIQUE INDEX fileindex_pathrevnum '
     r'    ON fileindex (pathid, revnum)',
 
     r'CREATE UNIQUE INDEX fileindex_pathnode '
     r'    ON fileindex (pathid, node)',
 
     # Provide a view over all file data for convenience.
     r'CREATE VIEW filedata AS '
     r'SELECT '
     r'    fileindex.id AS id, '
     r'    filepath.id AS pathid, '
     r'    filepath.path AS path, '
     r'    fileindex.revnum AS revnum, '
     r'    fileindex.node AS node, '
     r'    fileindex.p1rev AS p1rev, '
     r'    fileindex.p2rev AS p2rev, '
     r'    fileindex.linkrev AS linkrev, '
     r'    fileindex.flags AS flags, '
     r'    fileindex.deltaid AS deltaid, '
     r'    fileindex.deltabaseid AS deltabaseid '
     r'FROM filepath, fileindex '
     r'WHERE fileindex.pathid=filepath.id',
 
     r'PRAGMA user_version=%d' % CURRENT_SCHEMA_VERSION,
 ]
 
 def resolvedeltachain(db, pathid, node, revisioncache,
                       stoprids, zstddctx=None):
     """Resolve a delta chain for a file node."""
 
     # TODO the "not in ({stops})" here is possibly slowing down the query
     # because it needs to perform the lookup on every recursive invocation.
     # This could possibly be faster if we created a temporary query with
     # baseid "poisoned" to null and limited the recursive filter to
     # "is not null".
     res = db.execute(
         r'WITH RECURSIVE '
         r'    deltachain(deltaid, baseid) AS ('
         r'        SELECT deltaid, deltabaseid FROM fileindex '
         r'            WHERE pathid=? AND node=? '
         r'        UNION ALL '
         r'        SELECT fileindex.deltaid, deltabaseid '
         r'            FROM fileindex, deltachain '
         r'            WHERE '
         r'                fileindex.id=deltachain.baseid '
         r'                AND deltachain.baseid IS NOT NULL '
         r'                AND fileindex.id NOT IN ({stops}) '
         r'    ) '
         r'SELECT deltachain.baseid, compression, delta '
         r'FROM deltachain, delta '
         r'WHERE delta.id=deltachain.deltaid'.format(
             stops=r','.join([r'?'] * len(stoprids))),
         tuple([pathid, node] + list(stoprids.keys())))
 
     deltas = []
     lastdeltabaseid = None
 
     for deltabaseid, compression, delta in res:
         lastdeltabaseid = deltabaseid
 
         if compression == COMPRESSION_ZSTD:
             delta = zstddctx.decompress(delta)
         elif compression == COMPRESSION_NONE:
             delta = delta
         elif compression == COMPRESSION_ZLIB:
             delta = zlib.decompress(delta)
         else:
             raise SQLiteStoreError('unhandled compression type: %d' %
                                    compression)
 
         deltas.append(delta)
 
     if lastdeltabaseid in stoprids:
         basetext = revisioncache[stoprids[lastdeltabaseid]]
     else:
         basetext = deltas.pop()
 
     deltas.reverse()
     fulltext = mdiff.patches(basetext, deltas)
 
     # SQLite returns buffer instances for blob columns on Python 2. This
     # type can propagate through the delta application layer. Because
     # downstream callers assume revisions are bytes, cast as needed.
     if not isinstance(fulltext, bytes):
         fulltext = bytes(delta)
 
     return fulltext
 
 def insertdelta(db, compression, hash, delta):
     try:
         return db.execute(
             r'INSERT INTO delta (compression, hash, delta) '
             r'VALUES (?, ?, ?)',
             (compression, hash, delta)).lastrowid
     except sqlite3.IntegrityError:
         return db.execute(
             r'SELECT id FROM delta WHERE hash=?',
             (hash,)).fetchone()[0]
 
 class SQLiteStoreError(error.StorageError):
     pass
 
 @attr.s
 class revisionentry(object):
     rid = attr.ib()
     rev = attr.ib()
     node = attr.ib()
     p1rev = attr.ib()
     p2rev = attr.ib()
     p1node = attr.ib()
     p2node = attr.ib()
     linkrev = attr.ib()
     flags = attr.ib()
 
 @interfaceutil.implementer(repository.irevisiondelta)
 @attr.s(slots=True)
 class sqliterevisiondelta(object):
     node = attr.ib()
     p1node = attr.ib()
     p2node = attr.ib()
     basenode = attr.ib()
     flags = attr.ib()
     baserevisionsize = attr.ib()
     revision = attr.ib()
     delta = attr.ib()
     linknode = attr.ib(default=None)
 
 @interfaceutil.implementer(repository.iverifyproblem)
 @attr.s(frozen=True)
 class sqliteproblem(object):
     warning = attr.ib(default=None)
     error = attr.ib(default=None)
     node = attr.ib(default=None)
 
 @interfaceutil.implementer(repository.ifilestorage)
 class sqlitefilestore(object):
     """Implements storage for an individual tracked path."""
 
     def __init__(self, db, path, compression):
         self._db = db
         self._path = path
 
         self._pathid = None
 
         # revnum -> node
         self._revtonode = {}
         # node -> revnum
         self._nodetorev = {}
         # node -> data structure
         self._revisions = {}
 
         self._revisioncache = util.lrucachedict(10)
 
         self._compengine = compression
 
         if compression == 'zstd':
             self._cctx = zstd.ZstdCompressor(level=3)
             self._dctx = zstd.ZstdDecompressor()
         else:
             self._cctx = None
             self._dctx = None
 
         self._refreshindex()
 
     def _refreshindex(self):
         self._revtonode = {}
         self._nodetorev = {}
         self._revisions = {}
 
         res = list(self._db.execute(
             r'SELECT id FROM filepath WHERE path=?', (self._path,)))
 
         if not res:
             self._pathid = None
             return
 
         self._pathid = res[0][0]
 
         res = self._db.execute(
             r'SELECT id, revnum, node, p1rev, p2rev, linkrev, flags '
             r'FROM fileindex '
             r'WHERE pathid=? '
             r'ORDER BY revnum ASC',
             (self._pathid,))
 
         for i, row in enumerate(res):
             rid, rev, node, p1rev, p2rev, linkrev, flags = row
 
             if i != rev:
                 raise SQLiteStoreError(_('sqlite database has inconsistent '
                                          'revision numbers'))
 
             if p1rev == nullrev:
                 p1node = nullid
             else:
                 p1node = self._revtonode[p1rev]
 
             if p2rev == nullrev:
                 p2node = nullid
             else:
                 p2node = self._revtonode[p2rev]
 
             entry = revisionentry(
                 rid=rid,
                 rev=rev,
                 node=node,
                 p1rev=p1rev,
                 p2rev=p2rev,
                 p1node=p1node,
                 p2node=p2node,
                 linkrev=linkrev,
                 flags=flags)
 
             self._revtonode[rev] = node
             self._nodetorev[node] = rev
             self._revisions[node] = entry
 
     # Start of ifileindex interface.
 
     def __len__(self):
         return len(self._revisions)
 
     def __iter__(self):
         return iter(pycompat.xrange(len(self._revisions)))
 
+    def hasnode(self, node):
+        if node == nullid:
+            return False
+
+        return node in self._nodetorev
+
     def revs(self, start=0, stop=None):
         return storageutil.iterrevs(len(self._revisions), start=start,
                                     stop=stop)
 
     def parents(self, node):
         if node == nullid:
             return nullid, nullid
 
         if node not in self._revisions:
             raise error.LookupError(node, self._path, _('no node'))
 
         entry = self._revisions[node]
         return entry.p1node, entry.p2node
 
     def parentrevs(self, rev):
         if rev == nullrev:
             return nullrev, nullrev
 
         if rev not in self._revtonode:
             raise IndexError(rev)
 
         entry = self._revisions[self._revtonode[rev]]
         return entry.p1rev, entry.p2rev
 
     def rev(self, node):
         if node == nullid:
             return nullrev
 
         if node not in self._nodetorev:
             raise error.LookupError(node, self._path, _('no node'))
 
         return self._nodetorev[node]
 
     def node(self, rev):
         if rev == nullrev:
             return nullid
 
         if rev not in self._revtonode:
             raise IndexError(rev)
 
         return self._revtonode[rev]
 
     def lookup(self, node):
         return storageutil.fileidlookup(self, node, self._path)
 
     def linkrev(self, rev):
         if rev == nullrev:
             return nullrev
 
         if rev not in self._revtonode:
             raise IndexError(rev)
 
         entry = self._revisions[self._revtonode[rev]]
         return entry.linkrev
 
     def iscensored(self, rev):
         if rev == nullrev:
             return False
 
         if rev not in self._revtonode:
             raise IndexError(rev)
 
         return self._revisions[self._revtonode[rev]].flags & FLAG_CENSORED
 
     def commonancestorsheads(self, node1, node2):
         rev1 = self.rev(node1)
         rev2 = self.rev(node2)
 
         ancestors = ancestor.commonancestorsheads(self.parentrevs, rev1, rev2)
         return pycompat.maplist(self.node, ancestors)
 
     def descendants(self, revs):
         # TODO we could implement this using a recursive SQL query, which
         # might be faster.
         return dagop.descendantrevs(revs, self.revs, self.parentrevs)
 
     def heads(self, start=None, stop=None):
         if start is None and stop is None:
             if not len(self):
                 return [nullid]
 
         startrev = self.rev(start) if start is not None else nullrev
         stoprevs = {self.rev(n) for n in stop or []}
 
         revs = dagop.headrevssubset(self.revs, self.parentrevs,
                                     startrev=startrev, stoprevs=stoprevs)
 
         return [self.node(rev) for rev in revs]
 
     def children(self, node):
         rev = self.rev(node)
 
         res = self._db.execute(
             r'SELECT'
             r'  node '
             r'  FROM filedata '
             r'  WHERE path=? AND (p1rev=? OR p2rev=?) '
             r'  ORDER BY revnum ASC',
             (self._path, rev, rev))
 
         return [row[0] for row in res]
 
     # End of ifileindex interface.
 
     # Start of ifiledata interface.
 
     def size(self, rev):
         if rev == nullrev:
             return 0
 
         if rev not in self._revtonode:
             raise IndexError(rev)
 
         node = self._revtonode[rev]
 
         if self.renamed(node):
             return len(self.read(node))
 
         return len(self.revision(node))
 
     def revision(self, node, raw=False, _verifyhash=True):
         if node in (nullid, nullrev):
             return b''
 
         if isinstance(node, int):
             node = self.node(node)
 
         if node not in self._nodetorev:
             raise error.LookupError(node, self._path, _('no node'))
 
         if node in self._revisioncache:
             return self._revisioncache[node]
 
         # Because we have a fulltext revision cache, we are able to
         # short-circuit delta chain traversal and decompression as soon as
         # we encounter a revision in the cache.
 
         stoprids = {self._revisions[n].rid: n
                     for n in self._revisioncache}
 
         if not stoprids:
             stoprids[-1] = None
 
         fulltext = resolvedeltachain(self._db, self._pathid, node,
                                      self._revisioncache, stoprids,
                                      zstddctx=self._dctx)
 
         if _verifyhash:
             self._checkhash(fulltext, node)
             self._revisioncache[node] = fulltext
 
         return fulltext
 
     def read(self, node):
         return storageutil.filtermetadata(self.revision(node))
 
     def renamed(self, node):
         return storageutil.filerevisioncopied(self, node)
 
     def cmp(self, node, fulltext):
         return not storageutil.filedataequivalent(self, node, fulltext)
 
     def emitrevisions(self, nodes, nodesorder=None, revisiondata=False,
                       assumehaveparentrevisions=False, deltaprevious=False):
         if nodesorder not in ('nodes', 'storage', None):
             raise error.ProgrammingError('unhandled value for nodesorder: %s' %
                                          nodesorder)
 
         nodes = [n for n in nodes if n != nullid]
 
         if not nodes:
             return
 
         # TODO perform in a single query.
         res = self._db.execute(
             r'SELECT revnum, deltaid FROM fileindex '
             r'WHERE pathid=? '
             r'    AND node in (%s)' % (r','.join([r'?'] * len(nodes))),
             tuple([self._pathid] + nodes))
 
         deltabases = {}
 
         for rev, deltaid in res:
             res = self._db.execute(
                 r'SELECT revnum from fileindex WHERE pathid=? AND deltaid=?',
                 (self._pathid, deltaid))
             deltabases[rev] = res.fetchone()[0]
 
         # TODO define revdifffn so we can use delta from storage.
         for delta in storageutil.emitrevisions(
             self, nodes, nodesorder, sqliterevisiondelta,
             deltaparentfn=deltabases.__getitem__,
             revisiondata=revisiondata,
             assumehaveparentrevisions=assumehaveparentrevisions,
             deltaprevious=deltaprevious):
 
             yield delta
 
     # End of ifiledata interface.
 
     # Start of ifilemutation interface.
 
     def add(self, filedata, meta, transaction, linkrev, p1, p2):
         if meta or filedata.startswith(b'\x01\n'):
             filedata = storageutil.packmeta(meta, filedata)
 
         return self.addrevision(filedata, transaction, linkrev, p1, p2)
 
     def addrevision(self, revisiondata, transaction, linkrev, p1, p2, node=None,
                     flags=0, cachedelta=None):
         if flags:
             raise SQLiteStoreError(_('flags not supported on revisions'))
 
         validatehash = node is not None
         node = node or storageutil.hashrevisionsha1(revisiondata, p1, p2)
 
         if validatehash:
             self._checkhash(revisiondata, node, p1, p2)
 
         if node in self._nodetorev:
             return node
 
         node = self._addrawrevision(node, revisiondata, transaction, linkrev,
                                     p1, p2)
 
         self._revisioncache[node] = revisiondata
         return node
 
     def addgroup(self, deltas, linkmapper, transaction, addrevisioncb=None):
         nodes = []
 
         for node, p1, p2, linknode, deltabase, delta, wireflags in deltas:
             storeflags = 0
 
             if wireflags & repository.REVISION_FLAG_CENSORED:
                 storeflags |= FLAG_CENSORED
 
             if wireflags & ~repository.REVISION_FLAG_CENSORED:
                 raise SQLiteStoreError('unhandled revision flag')
 
             baserev = self.rev(deltabase)
 
             # If base is censored, delta must be full replacement in a single
             # patch operation.
             if baserev != nullrev and self.iscensored(baserev):
                 hlen = struct.calcsize('>lll')
                 oldlen = len(self.revision(deltabase, raw=True,
                                            _verifyhash=False))
                 newlen = len(delta) - hlen
 
                 if delta[:hlen] != mdiff.replacediffheader(oldlen, newlen):
                     raise error.CensoredBaseError(self._path,
                                                   deltabase)
 
             if (not (storeflags & FLAG_CENSORED)
                 and storageutil.deltaiscensored(
                     delta, baserev, lambda x: len(self.revision(x, raw=True)))):
                 storeflags |= FLAG_CENSORED
 
             linkrev = linkmapper(linknode)
 
             nodes.append(node)
 
             if node in self._revisions:
                 continue
 
             if deltabase == nullid:
                 text = mdiff.patch(b'', delta)
                 storedelta = None
             else:
                 text = None
                 storedelta = (deltabase, delta)
 
             self._addrawrevision(node, text, transaction, linkrev, p1, p2,
                                  storedelta=storedelta, flags=storeflags)
 
             if addrevisioncb:
                 addrevisioncb(self, node)
 
         return nodes
 
     def censorrevision(self, tr, censornode, tombstone=b''):
         tombstone = storageutil.packmeta({b'censored': tombstone}, b'')
 
         # This restriction is cargo culted from revlogs and makes no sense for
         # SQLite, since columns can be resized at will.
         if len(tombstone) > len(self.revision(censornode, raw=True)):
             raise error.Abort(_('censor tombstone must be no longer than '
                                 'censored data'))
 
         # We need to replace the censored revision's data with the tombstone.
         # But replacing that data will have implications for delta chains that
         # reference it.
         #
         # While "better," more complex strategies are possible, we do something
         # simple: we find delta chain children of the censored revision and we
         # replace those incremental deltas with fulltexts of their corresponding
         # revision. Then we delete the now-unreferenced delta and original
         # revision and insert a replacement.
 
         # Find the delta to be censored.
         censoreddeltaid = self._db.execute(
             r'SELECT deltaid FROM fileindex WHERE id=?',
             (self._revisions[censornode].rid,)).fetchone()[0]
 
         # Find all its delta chain children.
         # TODO once we support storing deltas for !files, we'll need to look
         # for those delta chains too.
         rows = list(self._db.execute(
             r'SELECT id, pathid, node FROM fileindex '
             r'WHERE deltabaseid=? OR deltaid=?',
             (censoreddeltaid, censoreddeltaid)))
 
         for row in rows:
             rid, pathid, node = row
 
             fulltext = resolvedeltachain(self._db, pathid, node, {}, {-1: None},
                                          zstddctx=self._dctx)
 
             deltahash = hashlib.sha1(fulltext).digest()
 
             if self._compengine == 'zstd':
                 deltablob = self._cctx.compress(fulltext)
                 compression = COMPRESSION_ZSTD
             elif self._compengine == 'zlib':
                 deltablob = zlib.compress(fulltext)
                 compression = COMPRESSION_ZLIB
             elif self._compengine == 'none':
                 deltablob = fulltext
                 compression = COMPRESSION_NONE
             else:
                 raise error.ProgrammingError('unhandled compression engine: %s'
                                              % self._compengine)
 
             if len(deltablob) >= len(fulltext):
                 deltablob = fulltext
                 compression = COMPRESSION_NONE
 
             deltaid = insertdelta(self._db, compression, deltahash, deltablob)
 
             self._db.execute(
                 r'UPDATE fileindex SET deltaid=?, deltabaseid=NULL '
                 r'WHERE id=?', (deltaid, rid))
 
         # Now create the tombstone delta and replace the delta on the censored
         # node.
         deltahash = hashlib.sha1(tombstone).digest()
         tombstonedeltaid = insertdelta(self._db, COMPRESSION_NONE,
                                        deltahash, tombstone)
 
         flags = self._revisions[censornode].flags
         flags |= FLAG_CENSORED
 
         self._db.execute(
             r'UPDATE fileindex SET flags=?, deltaid=?, deltabaseid=NULL '
             r'WHERE pathid=? AND node=?',
             (flags, tombstonedeltaid, self._pathid, censornode))
 
         self._db.execute(
             r'DELETE FROM delta WHERE id=?', (censoreddeltaid,))
 
         self._refreshindex()
         self._revisioncache.clear()
 
     def getstrippoint(self, minlink):
         return storageutil.resolvestripinfo(minlink, len(self) - 1,
                                             [self.rev(n) for n in self.heads()],
                                             self.linkrev,
                                             self.parentrevs)
 
     def strip(self, minlink, transaction):
         if not len(self):
             return
 
         rev, _ignored = self.getstrippoint(minlink)
 
         if rev == len(self):
             return
 
         for rev in self.revs(rev):
             self._db.execute(
                 r'DELETE FROM fileindex WHERE pathid=? AND node=?',
                 (self._pathid, self.node(rev)))
 
         # TODO how should we garbage collect data in delta table?
 
         self._refreshindex()
 
     # End of ifilemutation interface.
 
     # Start of ifilestorage interface.
 
     def files(self):
         return []
 
     def storageinfo(self, exclusivefiles=False, sharedfiles=False,
                     revisionscount=False, trackedsize=False,
                     storedsize=False):
         d = {}
 
         if exclusivefiles:
             d['exclusivefiles'] = []
 
         if sharedfiles:
             # TODO list sqlite file(s) here.
             d['sharedfiles'] = []
 
         if revisionscount:
             d['revisionscount'] = len(self)
 
         if trackedsize:
             d['trackedsize'] = sum(len(self.revision(node))
                                        for node in self._nodetorev)
 
         if storedsize:
             # TODO implement this?
             d['storedsize'] = None
 
         return d
 
     def verifyintegrity(self, state):
         state['skipread'] = set()
 
         for rev in self:
             node = self.node(rev)
 
             try:
                 self.revision(node)
             except Exception as e:
                 yield sqliteproblem(
                     error=_('unpacking %s: %s') % (short(node), e),
                     node=node)
 
                 state['skipread'].add(node)
 
     # End of ifilestorage interface.
 
     def _checkhash(self, fulltext, node, p1=None, p2=None):
         if p1 is None and p2 is None:
             p1, p2 = self.parents(node)
 
         if node == storageutil.hashrevisionsha1(fulltext, p1, p2):
             return
 
         try:
             del self._revisioncache[node]
         except KeyError:
             pass
 
         if storageutil.iscensoredtext(fulltext):
             raise error.CensoredNodeError(self._path, node, fulltext)
 
         raise SQLiteStoreError(_('integrity check failed on %s') %
                                self._path)
 
     def _addrawrevision(self, node, revisiondata, transaction, linkrev,
                         p1, p2, storedelta=None, flags=0):
         if self._pathid is None:
             res = self._db.execute(
                 r'INSERT INTO filepath (path) VALUES (?)', (self._path,))
             self._pathid = res.lastrowid
 
         # For simplicity, always store a delta against p1.
         # TODO we need a lot more logic here to make behavior reasonable.
 
         if storedelta:
             deltabase, delta = storedelta
 
             if isinstance(deltabase, int):
                 deltabase = self.node(deltabase)
 
         else:
             assert revisiondata is not None
             deltabase = p1
 
             if deltabase == nullid:
                 delta = revisiondata
             else:
                 delta = mdiff.textdiff(self.revision(self.rev(deltabase)),
                                        revisiondata)
 
         # File index stores a pointer to its delta and the parent delta.
         # The parent delta is stored via a pointer to the fileindex PK.
         if deltabase == nullid:
             baseid = None
         else:
             baseid = self._revisions[deltabase].rid
 
         # Deltas are stored with a hash of their content. This allows
         # us to de-duplicate. The table is configured to ignore conflicts
         # and it is faster to just insert and silently noop than to look
         # first.
         deltahash = hashlib.sha1(delta).digest()
 
         if self._compengine == 'zstd':
             deltablob = self._cctx.compress(delta)
             compression = COMPRESSION_ZSTD
         elif self._compengine == 'zlib':
             deltablob = zlib.compress(delta)
             compression = COMPRESSION_ZLIB
         elif self._compengine == 'none':
             deltablob = delta
             compression = COMPRESSION_NONE
         else:
             raise error.ProgrammingError('unhandled compression engine: %s' %
                                          self._compengine)
 
         # Don't store compressed data if it isn't practical.
         if len(deltablob) >= len(delta):
             deltablob = delta
             compression = COMPRESSION_NONE
 
         deltaid = insertdelta(self._db, compression, deltahash, deltablob)
 
         rev = len(self)
 
         if p1 == nullid:
             p1rev = nullrev
         else:
             p1rev = self._nodetorev[p1]
 
         if p2 == nullid:
             p2rev = nullrev
         else:
             p2rev = self._nodetorev[p2]
 
         rid = self._db.execute(
             r'INSERT INTO fileindex ('
             r'    pathid, revnum, node, p1rev, p2rev, linkrev, flags, '
             r'    deltaid, deltabaseid) '
             r'    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)',
             (self._pathid, rev, node, p1rev, p2rev, linkrev, flags,
              deltaid, baseid)
         ).lastrowid
 
         entry = revisionentry(
             rid=rid,
             rev=rev,
             node=node,
             p1rev=p1rev,
             p2rev=p2rev,
             p1node=p1,
             p2node=p2,
             linkrev=linkrev,
             flags=flags)
 
         self._nodetorev[node] = rev
         self._revtonode[rev] = node
         self._revisions[node] = entry
 
         return node
 
 class sqliterepository(localrepo.localrepository):
     def cancopy(self):
         return False
 
     def transaction(self, *args, **kwargs):
         current = self.currenttransaction()
 
         tr = super(sqliterepository, self).transaction(*args, **kwargs)
 
         if current:
             return tr
 
         self._dbconn.execute(r'BEGIN TRANSACTION')
 
         def committransaction(_):
             self._dbconn.commit()
 
         tr.addfinalize('sqlitestore', committransaction)
 
         return tr
 
     @property
     def _dbconn(self):
         # SQLite connections can only be used on the thread that created
         # them. In most cases, this "just works." However, hgweb uses
         # multiple threads.
         tid = threading.current_thread().ident
 
         if self._db:
             if self._db[0] == tid:
                 return self._db[1]
 
         db = makedb(self.svfs.join('db.sqlite'))
         self._db = (tid, db)
 
         return db
 
 def makedb(path):
     """Construct a database handle for a database at path."""
 
     db = sqlite3.connect(path)
     db.text_factory = bytes
 
     res = db.execute(r'PRAGMA user_version').fetchone()[0]
 
     # New database.
     if res == 0:
         for statement in CREATE_SCHEMA:
             db.execute(statement)
 
         db.commit()
 
     elif res == CURRENT_SCHEMA_VERSION:
         pass
 
     else:
         raise error.Abort(_('sqlite database has unrecognized version'))
 
     db.execute(r'PRAGMA journal_mode=WAL')
 
     return db
 
 def featuresetup(ui, supported):
     supported.add(REQUIREMENT)
 
     if zstd:
         supported.add(REQUIREMENT_ZSTD)
 
     supported.add(REQUIREMENT_ZLIB)
     supported.add(REQUIREMENT_NONE)
 
 def newreporequirements(orig, ui, createopts):
     if createopts['backend'] != 'sqlite':
         return orig(ui, createopts)
 
     # This restriction can be lifted once we have more confidence.
     if 'sharedrepo' in createopts:
         raise error.Abort(_('shared repositories not supported with SQLite '
                             'store'))
 
     # This filtering is out of an abundance of caution: we want to ensure
     # we honor creation options and we do that by annotating exactly the
     # creation options we recognize.
     known = {
         'narrowfiles',
         'backend',
     }
 
     unsupported = set(createopts) - known
     if unsupported:
         raise error.Abort(_('SQLite store does not support repo creation '
                             'option: %s') % ', '.join(sorted(unsupported)))
 
     # Since we're a hybrid store that still relies on revlogs, we fall back
     # to using the revlogv1 backend's storage requirements then adding our
     # own requirement.
     createopts['backend'] = 'revlogv1'
     requirements = orig(ui, createopts)
     requirements.add(REQUIREMENT)
 
     compression = ui.config('storage', 'sqlite.compression')
 
     if compression == 'zstd' and not zstd:
         raise error.Abort(_('storage.sqlite.compression set to "zstd" but '
                             'zstandard compression not available to this '
                             'Mercurial install'))
 
     if compression == 'zstd':
         requirements.add(REQUIREMENT_ZSTD)
     elif compression == 'zlib':
         requirements.add(REQUIREMENT_ZLIB)
     elif compression == 'none':
         requirements.add(REQUIREMENT_NONE)
     else:
         raise error.Abort(_('unknown compression engine defined in '
                             'storage.sqlite.compression: %s') % compression)
 
     return requirements
 
 @interfaceutil.implementer(repository.ilocalrepositoryfilestorage)
 class sqlitefilestorage(object):
     """Repository file storage backed by SQLite."""
     def file(self, path):
         if path[0] == b'/':
             path = path[1:]
 
         if REQUIREMENT_ZSTD in self.requirements:
             compression = 'zstd'
         elif REQUIREMENT_ZLIB in self.requirements:
             compression = 'zlib'
         elif REQUIREMENT_NONE in self.requirements:
             compression = 'none'
         else:
             raise error.Abort(_('unable to determine what compression engine '
                                 'to use for SQLite storage'))
 
         return sqlitefilestore(self._dbconn, path, compression)
 
 def makefilestorage(orig, requirements, **kwargs):
     """Produce a type conforming to ``ilocalrepositoryfilestorage``."""
     if REQUIREMENT in requirements:
         return sqlitefilestorage
     else:
         return orig(requirements=requirements, **kwargs)
 
 def makemain(orig, ui, requirements, **kwargs):
     if REQUIREMENT in requirements:
         if REQUIREMENT_ZSTD in requirements and not zstd:
             raise error.Abort(_('repository uses zstandard compression, which '
                                 'is not available to this Mercurial install'))
 
         return sqliterepository
 
     return orig(requirements=requirements, **kwargs)
 
 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(localrepo, 'makefilestorage',
                             makefilestorage)
     extensions.wrapfunction(localrepo, 'makemain',
                             makemain)
     extensions.wrapfunction(verify.verifier, '__init__',
                             verifierinit)
 
 def reposetup(ui, repo):
     if isinstance(repo, sqliterepository):
         repo._db = None
 
     # TODO check for bundlerepository?

mercurial/filelog.py

@@ -1,219 +1,233
 # filelog.py - file history class for mercurial
 #
 # Copyright 2005-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
 
+from .node import (
+    nullid,
+    nullrev,
+)
 from . import (
     error,
     repository,
     revlog,
 )
 from .utils import (
     interfaceutil,
     storageutil,
 )
 
 @interfaceutil.implementer(repository.ifilestorage)
 class filelog(object):
     def __init__(self, opener, path):
         self._revlog = revlog.revlog(opener,
                                      '/'.join(('data', path + '.i')),
                                      censorable=True)
         # Full name of the user visible file, relative to the repository root.
         # Used by LFS.
         self._revlog.filename = path
 
     def __len__(self):
         return len(self._revlog)
 
     def __iter__(self):
         return self._revlog.__iter__()
 
+    def hasnode(self, node):
+        if node in (nullid, nullrev):
+            return False
+
+        try:
+            self._revlog.rev(node)
+            return True
+        except (TypeError, ValueError, IndexError, error.LookupError):
+            return False
+
     def revs(self, start=0, stop=None):
         return self._revlog.revs(start=start, stop=stop)
 
     def parents(self, node):
         return self._revlog.parents(node)
 
     def parentrevs(self, rev):
         return self._revlog.parentrevs(rev)
 
     def rev(self, node):
         return self._revlog.rev(node)
 
     def node(self, rev):
         return self._revlog.node(rev)
 
     def lookup(self, node):
         return storageutil.fileidlookup(self._revlog, node,
                                         self._revlog.indexfile)
 
     def linkrev(self, rev):
         return self._revlog.linkrev(rev)
 
     def commonancestorsheads(self, node1, node2):
         return self._revlog.commonancestorsheads(node1, node2)
 
     # Used by dagop.blockdescendants().
     def descendants(self, revs):
         return self._revlog.descendants(revs)
 
     def heads(self, start=None, stop=None):
         return self._revlog.heads(start, stop)
 
     # Used by hgweb, children extension.
     def children(self, node):
         return self._revlog.children(node)
 
     def iscensored(self, rev):
         return self._revlog.iscensored(rev)
 
     def revision(self, node, _df=None, raw=False):
         return self._revlog.revision(node, _df=_df, raw=raw)
 
     def emitrevisions(self, nodes, nodesorder=None,
                       revisiondata=False, assumehaveparentrevisions=False,
                       deltaprevious=False):
         return self._revlog.emitrevisions(
             nodes, nodesorder=nodesorder, revisiondata=revisiondata,
             assumehaveparentrevisions=assumehaveparentrevisions,
             deltaprevious=deltaprevious)
 
     def addrevision(self, revisiondata, transaction, linkrev, p1, p2,
                     node=None, flags=revlog.REVIDX_DEFAULT_FLAGS,
                     cachedelta=None):
         return self._revlog.addrevision(revisiondata, transaction, linkrev,
                                     p1, p2, node=node, flags=flags,
                                     cachedelta=cachedelta)
 
     def addgroup(self, deltas, linkmapper, transaction, addrevisioncb=None):
         return self._revlog.addgroup(deltas, linkmapper, transaction,
                                  addrevisioncb=addrevisioncb)
 
     def getstrippoint(self, minlink):
         return self._revlog.getstrippoint(minlink)
 
     def strip(self, minlink, transaction):
         return self._revlog.strip(minlink, transaction)
 
     def censorrevision(self, tr, node, tombstone=b''):
         return self._revlog.censorrevision(tr, node, tombstone=tombstone)
 
     def files(self):
         return self._revlog.files()
 
     def read(self, node):
         return storageutil.filtermetadata(self.revision(node))
 
     def add(self, text, meta, transaction, link, p1=None, p2=None):
         if meta or text.startswith('\1\n'):
             text = storageutil.packmeta(meta, text)
         return self.addrevision(text, transaction, link, p1, p2)
 
     def renamed(self, node):
         return storageutil.filerevisioncopied(self, node)
 
     def size(self, rev):
         """return the size of a given revision"""
 
         # for revisions with renames, we have to go the slow way
         node = self.node(rev)
         if self.renamed(node):
             return len(self.read(node))
         if self.iscensored(rev):
             return 0
 
         # XXX if self.read(node).startswith("\1\n"), this returns (size+4)
         return self._revlog.size(rev)
 
     def cmp(self, node, text):
         """compare text with a given file revision
 
         returns True if text is different than what is stored.
         """
         return not storageutil.filedataequivalent(self, node, text)
 
     def verifyintegrity(self, state):
         return self._revlog.verifyintegrity(state)
 
     def storageinfo(self, exclusivefiles=False, sharedfiles=False,
                     revisionscount=False, trackedsize=False,
                     storedsize=False):
         return self._revlog.storageinfo(
             exclusivefiles=exclusivefiles, sharedfiles=sharedfiles,
             revisionscount=revisionscount, trackedsize=trackedsize,
             storedsize=storedsize)
 
     # TODO these aren't part of the interface and aren't internal methods.
     # Callers should be fixed to not use them.
 
     # Used by bundlefilelog, unionfilelog.
     @property
     def indexfile(self):
         return self._revlog.indexfile
 
     @indexfile.setter
     def indexfile(self, value):
         self._revlog.indexfile = value
 
     # Used by repo upgrade.
     def clone(self, tr, destrevlog, **kwargs):
         if not isinstance(destrevlog, filelog):
             raise error.ProgrammingError('expected filelog to clone()')
 
         return self._revlog.clone(tr, destrevlog._revlog, **kwargs)
 
 class narrowfilelog(filelog):
     """Filelog variation to be used with narrow stores."""
 
     def __init__(self, opener, path, narrowmatch):
         super(narrowfilelog, self).__init__(opener, path)
         self._narrowmatch = narrowmatch
 
     def renamed(self, node):
         res = super(narrowfilelog, self).renamed(node)
 
         # Renames that come from outside the narrowspec are problematic
         # because we may lack the base text for the rename. This can result
         # in code attempting to walk the ancestry or compute a diff
         # encountering a missing revision. We address this by silently
         # removing rename metadata if the source file is outside the
         # narrow spec.
         #
         # A better solution would be to see if the base revision is available,
         # rather than assuming it isn't.
         #
         # An even better solution would be to teach all consumers of rename
         # metadata that the base revision may not be available.
         #
         # TODO consider better ways of doing this.
         if res and not self._narrowmatch(res[0]):
             return None
 
         return res
 
     def size(self, rev):
         # Because we have a custom renamed() that may lie, we need to call
         # the base renamed() to report accurate results.
         node = self.node(rev)
         if super(narrowfilelog, self).renamed(node):
             return len(self.read(node))
         else:
             return super(narrowfilelog, self).size(rev)
 
     def cmp(self, node, text):
         different = super(narrowfilelog, self).cmp(node, text)
 
         # Because renamed() may lie, we may get false positives for
         # different content. Check for this by comparing against the original
         # renamed() implementation.
         if different:
             if super(narrowfilelog, self).renamed(node):
                 t2 = self.read(node)
                 return t2 != text
 
         return different

mercurial/repository.py

@@ -1,1835 +1,1845
 # repository.py - Interfaces and base classes for repositories and peers.
 #
 # Copyright 2017 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 from .i18n import _
 from . import (
     error,
 )
 from .utils import (
     interfaceutil,
 )
 
 # When narrowing is finalized and no longer subject to format changes,
 # we should move this to just "narrow" or similar.
 NARROW_REQUIREMENT = 'narrowhg-experimental'
 
 # Local repository feature string.
 
 # Revlogs are being used for file storage.
 REPO_FEATURE_REVLOG_FILE_STORAGE = b'revlogfilestorage'
 # The storage part of the repository is shared from an external source.
 REPO_FEATURE_SHARED_STORAGE = b'sharedstore'
 # LFS supported for backing file storage.
 REPO_FEATURE_LFS = b'lfs'
 # Repository supports being stream cloned.
 REPO_FEATURE_STREAM_CLONE = b'streamclone'
 
 REVISION_FLAG_CENSORED = 1 << 15
 REVISION_FLAG_ELLIPSIS = 1 << 14
 REVISION_FLAG_EXTSTORED = 1 << 13
 
 REVISION_FLAGS_KNOWN = (
     REVISION_FLAG_CENSORED | REVISION_FLAG_ELLIPSIS | REVISION_FLAG_EXTSTORED)
 
 class ipeerconnection(interfaceutil.Interface):
     """Represents a "connection" to a repository.
 
     This is the base interface for representing a connection to a repository.
     It holds basic properties and methods applicable to all peer types.
 
     This is not a complete interface definition and should not be used
     outside of this module.
     """
     ui = interfaceutil.Attribute("""ui.ui instance""")
 
     def url():
         """Returns a URL string representing this peer.
 
         Currently, implementations expose the raw URL used to construct the
         instance. It may contain credentials as part of the URL. The
         expectations of the value aren't well-defined and this could lead to
         data leakage.
 
         TODO audit/clean consumers and more clearly define the contents of this
         value.
         """
 
     def local():
         """Returns a local repository instance.
 
         If the peer represents a local repository, returns an object that
         can be used to interface with it. Otherwise returns ``None``.
         """
 
     def peer():
         """Returns an object conforming to this interface.
 
         Most implementations will ``return self``.
         """
 
     def canpush():
         """Returns a boolean indicating if this peer can be pushed to."""
 
     def close():
         """Close the connection to this peer.
 
         This is called when the peer will no longer be used. Resources
         associated with the peer should be cleaned up.
         """
 
 class ipeercapabilities(interfaceutil.Interface):
     """Peer sub-interface related to capabilities."""
 
     def capable(name):
         """Determine support for a named capability.
 
         Returns ``False`` if capability not supported.
 
         Returns ``True`` if boolean capability is supported. Returns a string
         if capability support is non-boolean.
 
         Capability strings may or may not map to wire protocol capabilities.
         """
 
     def requirecap(name, purpose):
         """Require a capability to be present.
 
         Raises a ``CapabilityError`` if the capability isn't present.
         """
 
 class ipeercommands(interfaceutil.Interface):
     """Client-side interface for communicating over the wire protocol.
 
     This interface is used as a gateway to the Mercurial wire protocol.
     methods commonly call wire protocol commands of the same name.
     """
 
     def branchmap():
         """Obtain heads in named branches.
 
         Returns a dict mapping branch name to an iterable of nodes that are
         heads on that branch.
         """
 
     def capabilities():
         """Obtain capabilities of the peer.
 
         Returns a set of string capabilities.
         """
 
     def clonebundles():
         """Obtains the clone bundles manifest for the repo.
 
         Returns the manifest as unparsed bytes.
         """
 
     def debugwireargs(one, two, three=None, four=None, five=None):
         """Used to facilitate debugging of arguments passed over the wire."""
 
     def getbundle(source, **kwargs):
         """Obtain remote repository data as a bundle.
 
         This command is how the bulk of repository data is transferred from
         the peer to the local repository
 
         Returns a generator of bundle data.
         """
 
     def heads():
         """Determine all known head revisions in the peer.
 
         Returns an iterable of binary nodes.
         """
 
     def known(nodes):
         """Determine whether multiple nodes are known.
 
         Accepts an iterable of nodes whose presence to check for.
 
         Returns an iterable of booleans indicating of the corresponding node
         at that index is known to the peer.
         """
 
     def listkeys(namespace):
         """Obtain all keys in a pushkey namespace.
 
         Returns an iterable of key names.
         """
 
     def lookup(key):
         """Resolve a value to a known revision.
 
         Returns a binary node of the resolved revision on success.
         """
 
     def pushkey(namespace, key, old, new):
         """Set a value using the ``pushkey`` protocol.
 
         Arguments correspond to the pushkey namespace and key to operate on and
         the old and new values for that key.
 
         Returns a string with the peer result. The value inside varies by the
         namespace.
         """
 
     def stream_out():
         """Obtain streaming clone data.
 
         Successful result should be a generator of data chunks.
         """
 
     def unbundle(bundle, heads, url):
         """Transfer repository data to the peer.
 
         This is how the bulk of data during a push is transferred.
 
         Returns the integer number of heads added to the peer.
         """
 
 class ipeerlegacycommands(interfaceutil.Interface):
     """Interface for implementing support for legacy wire protocol commands.
 
     Wire protocol commands transition to legacy status when they are no longer
     used by modern clients. To facilitate identifying which commands are
     legacy, the interfaces are split.
     """
 
     def between(pairs):
         """Obtain nodes between pairs of nodes.
 
         ``pairs`` is an iterable of node pairs.
 
         Returns an iterable of iterables of nodes corresponding to each
         requested pair.
         """
 
     def branches(nodes):
         """Obtain ancestor changesets of specific nodes back to a branch point.
 
         For each requested node, the peer finds the first ancestor node that is
         a DAG root or is a merge.
 
         Returns an iterable of iterables with the resolved values for each node.
         """
 
     def changegroup(nodes, source):
         """Obtain a changegroup with data for descendants of specified nodes."""
 
     def changegroupsubset(bases, heads, source):
         pass
 
 class ipeercommandexecutor(interfaceutil.Interface):
     """Represents a mechanism to execute remote commands.
 
     This is the primary interface for requesting that wire protocol commands
     be executed. Instances of this interface are active in a context manager
     and have a well-defined lifetime. When the context manager exits, all
     outstanding requests are waited on.
     """
 
     def callcommand(name, args):
         """Request that a named command be executed.
 
         Receives the command name and a dictionary of command arguments.
 
         Returns a ``concurrent.futures.Future`` that will resolve to the
         result of that command request. That exact value is left up to
         the implementation and possibly varies by command.
 
         Not all commands can coexist with other commands in an executor
         instance: it depends on the underlying wire protocol transport being
         used and the command itself.
 
         Implementations MAY call ``sendcommands()`` automatically if the
         requested command can not coexist with other commands in this executor.
 
         Implementations MAY call ``sendcommands()`` automatically when the
         future's ``result()`` is called. So, consumers using multiple
         commands with an executor MUST ensure that ``result()`` is not called
         until all command requests have been issued.
         """
 
     def sendcommands():
         """Trigger submission of queued command requests.
 
         Not all transports submit commands as soon as they are requested to
         run. When called, this method forces queued command requests to be
         issued. It will no-op if all commands have already been sent.
 
         When called, no more new commands may be issued with this executor.
         """
 
     def close():
         """Signal that this command request is finished.
 
         When called, no more new commands may be issued. All outstanding
         commands that have previously been issued are waited on before
         returning. This not only includes waiting for the futures to resolve,
         but also waiting for all response data to arrive. In other words,
         calling this waits for all on-wire state for issued command requests
         to finish.
 
         When used as a context manager, this method is called when exiting the
         context manager.
 
         This method may call ``sendcommands()`` if there are buffered commands.
         """
 
 class ipeerrequests(interfaceutil.Interface):
     """Interface for executing commands on a peer."""
 
     def commandexecutor():
         """A context manager that resolves to an ipeercommandexecutor.
 
         The object this resolves to can be used to issue command requests
         to the peer.
 
         Callers should call its ``callcommand`` method to issue command
         requests.
 
         A new executor should be obtained for each distinct set of commands
         (possibly just a single command) that the consumer wants to execute
         as part of a single operation or round trip. This is because some
         peers are half-duplex and/or don't support persistent connections.
         e.g. in the case of HTTP peers, commands sent to an executor represent
         a single HTTP request. While some peers may support multiple command
         sends over the wire per executor, consumers need to code to the least
         capable peer. So it should be assumed that command executors buffer
         called commands until they are told to send them and that each
         command executor could result in a new connection or wire-level request
         being issued.
         """
 
 class ipeerbase(ipeerconnection, ipeercapabilities, ipeerrequests):
     """Unified interface for peer repositories.
 
     All peer instances must conform to this interface.
     """
 
 class ipeerv2(ipeerconnection, ipeercapabilities, ipeerrequests):
     """Unified peer interface for wire protocol version 2 peers."""
 
     apidescriptor = interfaceutil.Attribute(
         """Data structure holding description of server API.""")
 
 @interfaceutil.implementer(ipeerbase)
 class peer(object):
     """Base class for peer repositories."""
 
     def capable(self, name):
         caps = self.capabilities()
         if name in caps:
             return True
 
         name = '%s=' % name
         for cap in caps:
             if cap.startswith(name):
                 return cap[len(name):]
 
         return False
 
     def requirecap(self, name, purpose):
         if self.capable(name):
             return
 
         raise error.CapabilityError(
             _('cannot %s; remote repository does not support the %r '
               'capability') % (purpose, name))
 
 class iverifyproblem(interfaceutil.Interface):
     """Represents a problem with the integrity of the repository.
 
     Instances of this interface are emitted to describe an integrity issue
     with a repository (e.g. corrupt storage, missing data, etc).
 
     Instances are essentially messages associated with severity.
     """
     warning = interfaceutil.Attribute(
         """Message indicating a non-fatal problem.""")
 
     error = interfaceutil.Attribute(
         """Message indicating a fatal problem.""")
 
     node = interfaceutil.Attribute(
         """Revision encountering the problem.
 
         ``None`` means the problem doesn't apply to a single revision.
         """)
 
 class irevisiondelta(interfaceutil.Interface):
     """Represents a delta between one revision and another.
 
     Instances convey enough information to allow a revision to be exchanged
     with another repository.
 
     Instances represent the fulltext revision data or a delta against
     another revision. Therefore the ``revision`` and ``delta`` attributes
     are mutually exclusive.
 
     Typically used for changegroup generation.
     """
 
     node = interfaceutil.Attribute(
         """20 byte node of this revision.""")
 
     p1node = interfaceutil.Attribute(
         """20 byte node of 1st parent of this revision.""")
 
     p2node = interfaceutil.Attribute(
         """20 byte node of 2nd parent of this revision.""")
 
     linknode = interfaceutil.Attribute(
         """20 byte node of the changelog revision this node is linked to.""")
 
     flags = interfaceutil.Attribute(
         """2 bytes of integer flags that apply to this revision.
 
         This is a bitwise composition of the ``REVISION_FLAG_*`` constants.
         """)
 
     basenode = interfaceutil.Attribute(
         """20 byte node of the revision this data is a delta against.
 
         ``nullid`` indicates that the revision is a full revision and not
         a delta.
         """)
 
     baserevisionsize = interfaceutil.Attribute(
         """Size of base revision this delta is against.
 
         May be ``None`` if ``basenode`` is ``nullid``.
         """)
 
     revision = interfaceutil.Attribute(
         """Raw fulltext of revision data for this node.""")
 
     delta = interfaceutil.Attribute(
         """Delta between ``basenode`` and ``node``.
 
         Stored in the bdiff delta format.
         """)
 
 class ifilerevisionssequence(interfaceutil.Interface):
     """Contains index data for all revisions of a file.
 
     Types implementing this behave like lists of tuples. The index
     in the list corresponds to the revision number. The values contain
     index metadata.
 
     The *null* revision (revision number -1) is always the last item
     in the index.
     """
 
     def __len__():
         """The total number of revisions."""
 
     def __getitem__(rev):
         """Returns the object having a specific revision number.
 
         Returns an 8-tuple with the following fields:
 
         offset+flags
            Contains the offset and flags for the revision. 64-bit unsigned
            integer where first 6 bytes are the offset and the next 2 bytes
            are flags. The offset can be 0 if it is not used by the store.
         compressed size
             Size of the revision data in the store. It can be 0 if it isn't
             needed by the store.
         uncompressed size
             Fulltext size. It can be 0 if it isn't needed by the store.
         base revision
             Revision number of revision the delta for storage is encoded
             against. -1 indicates not encoded against a base revision.
         link revision
             Revision number of changelog revision this entry is related to.
         p1 revision
             Revision number of 1st parent. -1 if no 1st parent.
         p2 revision
             Revision number of 2nd parent. -1 if no 1st parent.
         node
             Binary node value for this revision number.
 
         Negative values should index off the end of the sequence. ``-1``
         should return the null revision. ``-2`` should return the most
         recent revision.
         """
 
     def __contains__(rev):
         """Whether a revision number exists."""
 
     def insert(self, i, entry):
         """Add an item to the index at specific revision."""
 
 class ifileindex(interfaceutil.Interface):
     """Storage interface for index data of a single file.
 
     File storage data is divided into index metadata and data storage.
     This interface defines the index portion of the interface.
 
     The index logically consists of:
 
     * A mapping between revision numbers and nodes.
     * DAG data (storing and querying the relationship between nodes).
     * Metadata to facilitate storage.
     """
     def __len__():
         """Obtain the number of revisions stored for this file."""
 
     def __iter__():
         """Iterate over revision numbers for this file."""
 
+    def hasnode(node):
+        """Returns a bool indicating if a node is known to this store.
+
+        Implementations must only return True for full, binary node values:
+        hex nodes, revision numbers, and partial node matches must be
+        rejected.
+
+        The null node is never present.
+        """
+
     def revs(start=0, stop=None):
         """Iterate over revision numbers for this file, with control."""
 
     def parents(node):
         """Returns a 2-tuple of parent nodes for a revision.
 
         Values will be ``nullid`` if the parent is empty.
         """
 
     def parentrevs(rev):
         """Like parents() but operates on revision numbers."""
 
     def rev(node):
         """Obtain the revision number given a node.
 
         Raises ``error.LookupError`` if the node is not known.
         """
 
     def node(rev):
         """Obtain the node value given a revision number.
 
         Raises ``IndexError`` if the node is not known.
         """
 
     def lookup(node):
         """Attempt to resolve a value to a node.
 
         Value can be a binary node, hex node, revision number, or a string
         that can be converted to an integer.
 
         Raises ``error.LookupError`` if a node could not be resolved.
         """
 
     def linkrev(rev):
         """Obtain the changeset revision number a revision is linked to."""
 
     def iscensored(rev):
         """Return whether a revision's content has been censored."""
 
     def commonancestorsheads(node1, node2):
         """Obtain an iterable of nodes containing heads of common ancestors.
 
         See ``ancestor.commonancestorsheads()``.
         """
 
     def descendants(revs):
         """Obtain descendant revision numbers for a set of revision numbers.
 
         If ``nullrev`` is in the set, this is equivalent to ``revs()``.
         """
 
     def heads(start=None, stop=None):
         """Obtain a list of nodes that are DAG heads, with control.
 
         The set of revisions examined can be limited by specifying
         ``start`` and ``stop``. ``start`` is a node. ``stop`` is an
         iterable of nodes. DAG traversal starts at earlier revision
         ``start`` and iterates forward until any node in ``stop`` is
         encountered.
         """
 
     def children(node):
         """Obtain nodes that are children of a node.
 
         Returns a list of nodes.
         """
 
 class ifiledata(interfaceutil.Interface):
     """Storage interface for data storage of a specific file.
 
     This complements ``ifileindex`` and provides an interface for accessing
     data for a tracked file.
     """
     def size(rev):
         """Obtain the fulltext size of file data.
 
         Any metadata is excluded from size measurements.
         """
 
     def revision(node, raw=False):
         """"Obtain fulltext data for a node.
 
         By default, any storage transformations are applied before the data
         is returned. If ``raw`` is True, non-raw storage transformations
         are not applied.
 
         The fulltext data may contain a header containing metadata. Most
         consumers should use ``read()`` to obtain the actual file data.
         """
 
     def read(node):
         """Resolve file fulltext data.
 
         This is similar to ``revision()`` except any metadata in the data
         headers is stripped.
         """
 
     def renamed(node):
         """Obtain copy metadata for a node.
 
         Returns ``False`` if no copy metadata is stored or a 2-tuple of
         (path, node) from which this revision was copied.
         """
 
     def cmp(node, fulltext):
         """Compare fulltext to another revision.
 
         Returns True if the fulltext is different from what is stored.
 
         This takes copy metadata into account.
 
         TODO better document the copy metadata and censoring logic.
         """
 
     def emitrevisions(nodes,
                       nodesorder=None,
                       revisiondata=False,
                       assumehaveparentrevisions=False,
                       deltaprevious=False):
         """Produce ``irevisiondelta`` for revisions.
 
         Given an iterable of nodes, emits objects conforming to the
         ``irevisiondelta`` interface that describe revisions in storage.
 
         This method is a generator.
 
         The input nodes may be unordered. Implementations must ensure that a
         node's parents are emitted before the node itself. Transitively, this
         means that a node may only be emitted once all its ancestors in
         ``nodes`` have also been emitted.
 
         By default, emits "index" data (the ``node``, ``p1node``, and
         ``p2node`` attributes). If ``revisiondata`` is set, revision data
         will also be present on the emitted objects.
 
         With default argument values, implementations can choose to emit
         either fulltext revision data or a delta. When emitting deltas,
         implementations must consider whether the delta's base revision
         fulltext is available to the receiver.
 
         The base revision fulltext is guaranteed to be available if any of
         the following are met:
 
         * Its fulltext revision was emitted by this method call.
         * A delta for that revision was emitted by this method call.
         * ``assumehaveparentrevisions`` is True and the base revision is a
           parent of the node.
 
         ``nodesorder`` can be used to control the order that revisions are
         emitted. By default, revisions can be reordered as long as they are
         in DAG topological order (see above). If the value is ``nodes``,
         the iteration order from ``nodes`` should be used. If the value is
         ``storage``, then the native order from the backing storage layer
         is used. (Not all storage layers will have strong ordering and behavior
         of this mode is storage-dependent.) ``nodes`` ordering can force
         revisions to be emitted before their ancestors, so consumers should
         use it with care.
 
         The ``linknode`` attribute on the returned ``irevisiondelta`` may not
         be set and it is the caller's responsibility to resolve it, if needed.
 
         If ``deltaprevious`` is True and revision data is requested, all
         revision data should be emitted as deltas against the revision
         emitted just prior. The initial revision should be a delta against
         its 1st parent.
         """
 
 class ifilemutation(interfaceutil.Interface):
     """Storage interface for mutation events of a tracked file."""
 
     def add(filedata, meta, transaction, linkrev, p1, p2):
         """Add a new revision to the store.
 
         Takes file data, dictionary of metadata, a transaction, linkrev,
         and parent nodes.
 
         Returns the node that was added.
 
         May no-op if a revision matching the supplied data is already stored.
         """
 
     def addrevision(revisiondata, transaction, linkrev, p1, p2, node=None,
                     flags=0, cachedelta=None):
         """Add a new revision to the store.
 
         This is similar to ``add()`` except it operates at a lower level.
 
         The data passed in already contains a metadata header, if any.
 
         ``node`` and ``flags`` can be used to define the expected node and
         the flags to use with storage. ``flags`` is a bitwise value composed
         of the various ``REVISION_FLAG_*`` constants.
 
         ``add()`` is usually called when adding files from e.g. the working
         directory. ``addrevision()`` is often called by ``add()`` and for
         scenarios where revision data has already been computed, such as when
         applying raw data from a peer repo.
         """
 
     def addgroup(deltas, linkmapper, transaction, addrevisioncb=None):
         """Process a series of deltas for storage.
 
         ``deltas`` is an iterable of 7-tuples of
         (node, p1, p2, linknode, deltabase, delta, flags) defining revisions
         to add.
 
         The ``delta`` field contains ``mpatch`` data to apply to a base
         revision, identified by ``deltabase``. The base node can be
         ``nullid``, in which case the header from the delta can be ignored
         and the delta used as the fulltext.
 
         ``addrevisioncb`` should be called for each node as it is committed.
 
         Returns a list of nodes that were processed. A node will be in the list
         even if it existed in the store previously.
         """
 
     def censorrevision(tr, node, tombstone=b''):
         """Remove the content of a single revision.
 
         The specified ``node`` will have its content purged from storage.
         Future attempts to access the revision data for this node will
         result in failure.
 
         A ``tombstone`` message can optionally be stored. This message may be
         displayed to users when they attempt to access the missing revision
         data.
 
         Storage backends may have stored deltas against the previous content
         in this revision. As part of censoring a revision, these storage
         backends are expected to rewrite any internally stored deltas such
         that they no longer reference the deleted content.
         """
 
     def getstrippoint(minlink):
         """Find the minimum revision that must be stripped to strip a linkrev.
 
         Returns a 2-tuple containing the minimum revision number and a set
         of all revisions numbers that would be broken by this strip.
 
         TODO this is highly revlog centric and should be abstracted into
         a higher-level deletion API. ``repair.strip()`` relies on this.
         """
 
     def strip(minlink, transaction):
         """Remove storage of items starting at a linkrev.
 
         This uses ``getstrippoint()`` to determine the first node to remove.
         Then it effectively truncates storage for all revisions after that.
 
         TODO this is highly revlog centric and should be abstracted into a
         higher-level deletion API.
         """
 
 class ifilestorage(ifileindex, ifiledata, ifilemutation):
     """Complete storage interface for a single tracked file."""
 
     def files():
         """Obtain paths that are backing storage for this file.
 
         TODO this is used heavily by verify code and there should probably
         be a better API for that.
         """
 
     def storageinfo(exclusivefiles=False, sharedfiles=False,
                     revisionscount=False, trackedsize=False,
                     storedsize=False):
         """Obtain information about storage for this file's data.
 
         Returns a dict describing storage for this tracked path. The keys
         in the dict map to arguments of the same. The arguments are bools
         indicating whether to calculate and obtain that data.
 
         exclusivefiles
            Iterable of (vfs, path) describing files that are exclusively
            used to back storage for this tracked path.
 
         sharedfiles
            Iterable of (vfs, path) describing files that are used to back
            storage for this tracked path. Those files may also provide storage
            for other stored entities.
 
         revisionscount
            Number of revisions available for retrieval.
 
         trackedsize
            Total size in bytes of all tracked revisions. This is a sum of the
            length of the fulltext of all revisions.
 
         storedsize
            Total size in bytes used to store data for all tracked revisions.
            This is commonly less than ``trackedsize`` due to internal usage
            of deltas rather than fulltext revisions.
 
         Not all storage backends may support all queries are have a reasonable
         value to use. In that case, the value should be set to ``None`` and
         callers are expected to handle this special value.
         """
 
     def verifyintegrity(state):
         """Verifies the integrity of file storage.
 
         ``state`` is a dict holding state of the verifier process. It can be
         used to communicate data between invocations of multiple storage
         primitives.
 
         If individual revisions cannot have their revision content resolved,
         the method is expected to set the ``skipread`` key to a set of nodes
         that encountered problems.
 
         The method yields objects conforming to the ``iverifyproblem``
         interface.
         """
 
 class idirs(interfaceutil.Interface):
     """Interface representing a collection of directories from paths.
 
     This interface is essentially a derived data structure representing
     directories from a collection of paths.
     """
 
     def addpath(path):
         """Add a path to the collection.
 
         All directories in the path will be added to the collection.
         """
 
     def delpath(path):
         """Remove a path from the collection.
 
         If the removal was the last path in a particular directory, the
         directory is removed from the collection.
         """
 
     def __iter__():
         """Iterate over the directories in this collection of paths."""
 
     def __contains__(path):
         """Whether a specific directory is in this collection."""
 
 class imanifestdict(interfaceutil.Interface):
     """Interface representing a manifest data structure.
 
     A manifest is effectively a dict mapping paths to entries. Each entry
     consists of a binary node and extra flags affecting that entry.
     """
 
     def __getitem__(path):
         """Returns the binary node value for a path in the manifest.
 
         Raises ``KeyError`` if the path does not exist in the manifest.
 
         Equivalent to ``self.find(path)[0]``.
         """
 
     def find(path):
         """Returns the entry for a path in the manifest.
 
         Returns a 2-tuple of (node, flags).
 
         Raises ``KeyError`` if the path does not exist in the manifest.
         """
 
     def __len__():
         """Return the number of entries in the manifest."""
 
     def __nonzero__():
         """Returns True if the manifest has entries, False otherwise."""
 
     __bool__ = __nonzero__
 
     def __setitem__(path, node):
         """Define the node value for a path in the manifest.
 
         If the path is already in the manifest, its flags will be copied to
         the new entry.
         """
 
     def __contains__(path):
         """Whether a path exists in the manifest."""
 
     def __delitem__(path):
         """Remove a path from the manifest.
 
         Raises ``KeyError`` if the path is not in the manifest.
         """
 
     def __iter__():
         """Iterate over paths in the manifest."""
 
     def iterkeys():
         """Iterate over paths in the manifest."""
 
     def keys():
         """Obtain a list of paths in the manifest."""
 
     def filesnotin(other, match=None):
         """Obtain the set of paths in this manifest but not in another.
 
         ``match`` is an optional matcher function to be applied to both
         manifests.
 
         Returns a set of paths.
         """
 
     def dirs():
         """Returns an object implementing the ``idirs`` interface."""
 
     def hasdir(dir):
         """Returns a bool indicating if a directory is in this manifest."""
 
     def matches(match):
         """Generate a new manifest filtered through a matcher.
 
         Returns an object conforming to the ``imanifestdict`` interface.
         """
 
     def walk(match):
         """Generator of paths in manifest satisfying a matcher.
 
         This is equivalent to ``self.matches(match).iterkeys()`` except a new
         manifest object is not created.
 
         If the matcher has explicit files listed and they don't exist in
         the manifest, ``match.bad()`` is called for each missing file.
         """
 
     def diff(other, match=None, clean=False):
         """Find differences between this manifest and another.
 
         This manifest is compared to ``other``.
 
         If ``match`` is provided, the two manifests are filtered against this
         matcher and only entries satisfying the matcher are compared.
 
         If ``clean`` is True, unchanged files are included in the returned
         object.
 
         Returns a dict with paths as keys and values of 2-tuples of 2-tuples of
         the form ``((node1, flag1), (node2, flag2))`` where ``(node1, flag1)``
         represents the node and flags for this manifest and ``(node2, flag2)``
         are the same for the other manifest.
         """
 
     def setflag(path, flag):
         """Set the flag value for a given path.
 
         Raises ``KeyError`` if the path is not already in the manifest.
         """
 
     def get(path, default=None):
         """Obtain the node value for a path or a default value if missing."""
 
     def flags(path, default=''):
         """Return the flags value for a path or a default value if missing."""
 
     def copy():
         """Return a copy of this manifest."""
 
     def items():
         """Returns an iterable of (path, node) for items in this manifest."""
 
     def iteritems():
         """Identical to items()."""
 
     def iterentries():
         """Returns an iterable of (path, node, flags) for this manifest.
 
         Similar to ``iteritems()`` except items are a 3-tuple and include
         flags.
         """
 
     def text():
         """Obtain the raw data representation for this manifest.
 
         Result is used to create a manifest revision.
         """
 
     def fastdelta(base, changes):
         """Obtain a delta between this manifest and another given changes.
 
         ``base`` in the raw data representation for another manifest.
 
         ``changes`` is an iterable of ``(path, to_delete)``.
 
         Returns a 2-tuple containing ``bytearray(self.text())`` and the
         delta between ``base`` and this manifest.
         """
 
 class imanifestrevisionbase(interfaceutil.Interface):
     """Base interface representing a single revision of a manifest.
 
     Should not be used as a primary interface: should always be inherited
     as part of a larger interface.
     """
 
     def new():
         """Obtain a new manifest instance.
 
         Returns an object conforming to the ``imanifestrevisionwritable``
         interface. The instance will be associated with the same
         ``imanifestlog`` collection as this instance.
         """
 
     def copy():
         """Obtain a copy of this manifest instance.
 
         Returns an object conforming to the ``imanifestrevisionwritable``
         interface. The instance will be associated with the same
         ``imanifestlog`` collection as this instance.
         """
 
     def read():
         """Obtain the parsed manifest data structure.
 
         The returned object conforms to the ``imanifestdict`` interface.
         """
 
 class imanifestrevisionstored(imanifestrevisionbase):
     """Interface representing a manifest revision committed to storage."""
 
     def node():
         """The binary node for this manifest."""
 
     parents = interfaceutil.Attribute(
         """List of binary nodes that are parents for this manifest revision."""
     )
 
     def readdelta(shallow=False):
         """Obtain the manifest data structure representing changes from parent.
 
         This manifest is compared to its 1st parent. A new manifest representing
         those differences is constructed.
 
         The returned object conforms to the ``imanifestdict`` interface.
         """
 
     def readfast(shallow=False):
         """Calls either ``read()`` or ``readdelta()``.
 
         The faster of the two options is called.
         """
 
     def find(key):
         """Calls self.read().find(key)``.
 
         Returns a 2-tuple of ``(node, flags)`` or raises ``KeyError``.
         """
 
 class imanifestrevisionwritable(imanifestrevisionbase):
     """Interface representing a manifest revision that can be committed."""
 
     def write(transaction, linkrev, p1node, p2node, added, removed, match=None):
         """Add this revision to storage.
 
         Takes a transaction object, the changeset revision number it will
         be associated with, its parent nodes, and lists of added and
         removed paths.
 
         If match is provided, storage can choose not to inspect or write out
         items that do not match. Storage is still required to be able to provide
         the full manifest in the future for any directories written (these
         manifests should not be "narrowed on disk").
 
         Returns the binary node of the created revision.
         """
 
 class imanifeststorage(interfaceutil.Interface):
     """Storage interface for manifest data."""
 
     tree = interfaceutil.Attribute(
         """The path to the directory this manifest tracks.
 
         The empty bytestring represents the root manifest.
         """)
 
     index = interfaceutil.Attribute(
         """An ``ifilerevisionssequence`` instance.""")
 
     indexfile = interfaceutil.Attribute(
         """Path of revlog index file.
 
         TODO this is revlog specific and should not be exposed.
         """)
 
     opener = interfaceutil.Attribute(
         """VFS opener to use to access underlying files used for storage.
 
         TODO this is revlog specific and should not be exposed.
         """)
 
     version = interfaceutil.Attribute(
         """Revlog version number.
 
         TODO this is revlog specific and should not be exposed.
         """)
 
     _generaldelta = interfaceutil.Attribute(
         """Whether generaldelta storage is being used.
 
         TODO this is revlog specific and should not be exposed.
         """)
 
     fulltextcache = interfaceutil.Attribute(
         """Dict with cache of fulltexts.
 
         TODO this doesn't feel appropriate for the storage interface.
         """)
 
     def __len__():
         """Obtain the number of revisions stored for this manifest."""
 
     def __iter__():
         """Iterate over revision numbers for this manifest."""
 
     def rev(node):
         """Obtain the revision number given a binary node.
 
         Raises ``error.LookupError`` if the node is not known.
         """
 
     def node(rev):
         """Obtain the node value given a revision number.
 
         Raises ``error.LookupError`` if the revision is not known.
         """
 
     def lookup(value):
         """Attempt to resolve a value to a node.
 
         Value can be a binary node, hex node, revision number, or a bytes
         that can be converted to an integer.
 
         Raises ``error.LookupError`` if a ndoe could not be resolved.
         """
 
     def parents(node):
         """Returns a 2-tuple of parent nodes for a node.
 
         Values will be ``nullid`` if the parent is empty.
         """
 
     def parentrevs(rev):
         """Like parents() but operates on revision numbers."""
 
     def linkrev(rev):
         """Obtain the changeset revision number a revision is linked to."""
 
     def revision(node, _df=None, raw=False):
         """Obtain fulltext data for a node."""
 
     def revdiff(rev1, rev2):
         """Obtain a delta between two revision numbers.
 
         The returned data is the result of ``bdiff.bdiff()`` on the raw
         revision data.
         """
 
     def cmp(node, fulltext):
         """Compare fulltext to another revision.
 
         Returns True if the fulltext is different from what is stored.
         """
 
     def emitrevisions(nodes,
                       nodesorder=None,
                       revisiondata=False,
                       assumehaveparentrevisions=False):
         """Produce ``irevisiondelta`` describing revisions.
 
         See the documentation for ``ifiledata`` for more.
         """
 
     def addgroup(deltas, linkmapper, transaction, addrevisioncb=None):
         """Process a series of deltas for storage.
 
         See the documentation in ``ifilemutation`` for more.
         """
 
     def rawsize(rev):
         """Obtain the size of tracked data.
 
         Is equivalent to ``len(m.revision(node, raw=True))``.
 
         TODO this method is only used by upgrade code and may be removed.
         """
 
     def getstrippoint(minlink):
         """Find minimum revision that must be stripped to strip a linkrev.
 
         See the documentation in ``ifilemutation`` for more.
         """
 
     def strip(minlink, transaction):
         """Remove storage of items starting at a linkrev.
 
         See the documentation in ``ifilemutation`` for more.
         """
 
     def checksize():
         """Obtain the expected sizes of backing files.
 
         TODO this is used by verify and it should not be part of the interface.
         """
 
     def files():
         """Obtain paths that are backing storage for this manifest.
 
         TODO this is used by verify and there should probably be a better API
         for this functionality.
         """
 
     def deltaparent(rev):
         """Obtain the revision that a revision is delta'd against.
 
         TODO delta encoding is an implementation detail of storage and should
         not be exposed to the storage interface.
         """
 
     def clone(tr, dest, **kwargs):
         """Clone this instance to another."""
 
     def clearcaches(clear_persisted_data=False):
         """Clear any caches associated with this instance."""
 
     def dirlog(d):
         """Obtain a manifest storage instance for a tree."""
 
     def add(m, transaction, link, p1, p2, added, removed, readtree=None,
             match=None):
         """Add a revision to storage.
 
         ``m`` is an object conforming to ``imanifestdict``.
 
         ``link`` is the linkrev revision number.
 
         ``p1`` and ``p2`` are the parent revision numbers.
 
         ``added`` and ``removed`` are iterables of added and removed paths,
         respectively.
 
         ``readtree`` is a function that can be used to read the child tree(s)
         when recursively writing the full tree structure when using
         treemanifets.
 
         ``match`` is a matcher that can be used to hint to storage that not all
         paths must be inspected; this is an optimization and can be safely
         ignored. Note that the storage must still be able to reproduce a full
         manifest including files that did not match.
         """
 
     def storageinfo(exclusivefiles=False, sharedfiles=False,
                     revisionscount=False, trackedsize=False,
                     storedsize=False):
         """Obtain information about storage for this manifest's data.
 
         See ``ifilestorage.storageinfo()`` for a description of this method.
         This one behaves the same way, except for manifest data.
         """
 
 class imanifestlog(interfaceutil.Interface):
     """Interface representing a collection of manifest snapshots.
 
     Represents the root manifest in a repository.
 
     Also serves as a means to access nested tree manifests and to cache
     tree manifests.
     """
 
     def __getitem__(node):
         """Obtain a manifest instance for a given binary node.
 
         Equivalent to calling ``self.get('', node)``.
 
         The returned object conforms to the ``imanifestrevisionstored``
         interface.
         """
 
     def get(tree, node, verify=True):
         """Retrieve the manifest instance for a given directory and binary node.
 
         ``node`` always refers to the node of the root manifest (which will be
         the only manifest if flat manifests are being used).
 
         If ``tree`` is the empty string, the root manifest is returned.
         Otherwise the manifest for the specified directory will be returned
         (requires tree manifests).
 
         If ``verify`` is True, ``LookupError`` is raised if the node is not
         known.
 
         The returned object conforms to the ``imanifestrevisionstored``
         interface.
         """
 
     def getstorage(tree):
         """Retrieve an interface to storage for a particular tree.
 
         If ``tree`` is the empty bytestring, storage for the root manifest will
         be returned. Otherwise storage for a tree manifest is returned.
 
         TODO formalize interface for returned object.
         """
 
     def clearcaches():
         """Clear caches associated with this collection."""
 
     def rev(node):
         """Obtain the revision number for a binary node.
 
         Raises ``error.LookupError`` if the node is not known.
         """
 
 class ilocalrepositoryfilestorage(interfaceutil.Interface):
     """Local repository sub-interface providing access to tracked file storage.
 
     This interface defines how a repository accesses storage for a single
     tracked file path.
     """
 
     def file(f):
         """Obtain a filelog for a tracked path.
 
         The returned type conforms to the ``ifilestorage`` interface.
         """
 
 class ilocalrepositorymain(interfaceutil.Interface):
     """Main interface for local repositories.
 
     This currently captures the reality of things - not how things should be.
     """
 
     supportedformats = interfaceutil.Attribute(
         """Set of requirements that apply to stream clone.
 
         This is actually a class attribute and is shared among all instances.
         """)
 
     supported = interfaceutil.Attribute(
         """Set of requirements that this repo is capable of opening.""")
 
     requirements = interfaceutil.Attribute(
         """Set of requirements this repo uses.""")
 
     features = interfaceutil.Attribute(
         """Set of "features" this repository supports.
 
         A "feature" is a loosely-defined term. It can refer to a feature
         in the classical sense or can describe an implementation detail
         of the repository. For example, a ``readonly`` feature may denote
         the repository as read-only. Or a ``revlogfilestore`` feature may
         denote that the repository is using revlogs for file storage.
 
         The intent of features is to provide a machine-queryable mechanism
         for repo consumers to test for various repository characteristics.
 
         Features are similar to ``requirements``. The main difference is that
         requirements are stored on-disk and represent requirements to open the
         repository. Features are more run-time capabilities of the repository
         and more granular capabilities (which may be derived from requirements).
         """)
 
     filtername = interfaceutil.Attribute(
         """Name of the repoview that is active on this repo.""")
 
     wvfs = interfaceutil.Attribute(
         """VFS used to access the working directory.""")
 
     vfs = interfaceutil.Attribute(
         """VFS rooted at the .hg directory.
 
         Used to access repository data not in the store.
         """)
 
     svfs = interfaceutil.Attribute(
         """VFS rooted at the store.
 
         Used to access repository data in the store. Typically .hg/store.
         But can point elsewhere if the store is shared.
         """)
 
     root = interfaceutil.Attribute(
         """Path to the root of the working directory.""")
 
     path = interfaceutil.Attribute(
         """Path to the .hg directory.""")
 
     origroot = interfaceutil.Attribute(
         """The filesystem path that was used to construct the repo.""")
 
     auditor = interfaceutil.Attribute(
         """A pathauditor for the working directory.
 
         This checks if a path refers to a nested repository.
 
         Operates on the filesystem.
         """)
 
     nofsauditor = interfaceutil.Attribute(
         """A pathauditor for the working directory.
 
         This is like ``auditor`` except it doesn't do filesystem checks.
         """)
 
     baseui = interfaceutil.Attribute(
         """Original ui instance passed into constructor.""")
 
     ui = interfaceutil.Attribute(
         """Main ui instance for this instance.""")
 
     sharedpath = interfaceutil.Attribute(
         """Path to the .hg directory of the repo this repo was shared from.""")
 
     store = interfaceutil.Attribute(
         """A store instance.""")
 
     spath = interfaceutil.Attribute(
         """Path to the store.""")
 
     sjoin = interfaceutil.Attribute(
         """Alias to self.store.join.""")
 
     cachevfs = interfaceutil.Attribute(
         """A VFS used to access the cache directory.
 
         Typically .hg/cache.
         """)
 
     filteredrevcache = interfaceutil.Attribute(
         """Holds sets of revisions to be filtered.""")
 
     names = interfaceutil.Attribute(
         """A ``namespaces`` instance.""")
 
     def close():
         """Close the handle on this repository."""
 
     def peer():
         """Obtain an object conforming to the ``peer`` interface."""
 
     def unfiltered():
         """Obtain an unfiltered/raw view of this repo."""
 
     def filtered(name, visibilityexceptions=None):
         """Obtain a named view of this repository."""
 
     obsstore = interfaceutil.Attribute(
         """A store of obsolescence data.""")
 
     changelog = interfaceutil.Attribute(
         """A handle on the changelog revlog.""")
 
     manifestlog = interfaceutil.Attribute(
         """An instance conforming to the ``imanifestlog`` interface.
 
         Provides access to manifests for the repository.
         """)
 
     dirstate = interfaceutil.Attribute(
         """Working directory state.""")
 
     narrowpats = interfaceutil.Attribute(
         """Matcher patterns for this repository's narrowspec.""")
 
     def narrowmatch():
         """Obtain a matcher for the narrowspec."""
 
     def setnarrowpats(newincludes, newexcludes):
         """Define the narrowspec for this repository."""
 
     def __getitem__(changeid):
         """Try to resolve a changectx."""
 
     def __contains__(changeid):
         """Whether a changeset exists."""
 
     def __nonzero__():
         """Always returns True."""
         return True
 
     __bool__ = __nonzero__
 
     def __len__():
         """Returns the number of changesets in the repo."""
 
     def __iter__():
         """Iterate over revisions in the changelog."""
 
     def revs(expr, *args):
         """Evaluate a revset.
 
         Emits revisions.
         """
 
     def set(expr, *args):
         """Evaluate a revset.
 
         Emits changectx instances.
         """
 
     def anyrevs(specs, user=False, localalias=None):
         """Find revisions matching one of the given revsets."""
 
     def url():
         """Returns a string representing the location of this repo."""
 
     def hook(name, throw=False, **args):
         """Call a hook."""
 
     def tags():
         """Return a mapping of tag to node."""
 
     def tagtype(tagname):
         """Return the type of a given tag."""
 
     def tagslist():
         """Return a list of tags ordered by revision."""
 
     def nodetags(node):
         """Return the tags associated with a node."""
 
     def nodebookmarks(node):
         """Return the list of bookmarks pointing to the specified node."""
 
     def branchmap():
         """Return a mapping of branch to heads in that branch."""
 
     def revbranchcache():
         pass
 
     def branchtip(branchtip, ignoremissing=False):
         """Return the tip node for a given branch."""
 
     def lookup(key):
         """Resolve the node for a revision."""
 
     def lookupbranch(key):
         """Look up the branch name of the given revision or branch name."""
 
     def known(nodes):
         """Determine whether a series of nodes is known.
 
         Returns a list of bools.
         """
 
     def local():
         """Whether the repository is local."""
         return True
 
     def publishing():
         """Whether the repository is a publishing repository."""
 
     def cancopy():
         pass
 
     def shared():
         """The type of shared repository or None."""
 
     def wjoin(f, *insidef):
         """Calls self.vfs.reljoin(self.root, f, *insidef)"""
 
     def setparents(p1, p2):
         """Set the parent nodes of the working directory."""
 
     def filectx(path, changeid=None, fileid=None):
         """Obtain a filectx for the given file revision."""
 
     def getcwd():
         """Obtain the current working directory from the dirstate."""
 
     def pathto(f, cwd=None):
         """Obtain the relative path to a file."""
 
     def adddatafilter(name, fltr):
         pass
 
     def wread(filename):
         """Read a file from wvfs, using data filters."""
 
     def wwrite(filename, data, flags, backgroundclose=False, **kwargs):
         """Write data to a file in the wvfs, using data filters."""
 
     def wwritedata(filename, data):
         """Resolve data for writing to the wvfs, using data filters."""
 
     def currenttransaction():
         """Obtain the current transaction instance or None."""
 
     def transaction(desc, report=None):
         """Open a new transaction to write to the repository."""
 
     def undofiles():
         """Returns a list of (vfs, path) for files to undo transactions."""
 
     def recover():
         """Roll back an interrupted transaction."""
 
     def rollback(dryrun=False, force=False):
         """Undo the last transaction.
 
         DANGEROUS.
         """
 
     def updatecaches(tr=None, full=False):
         """Warm repo caches."""
 
     def invalidatecaches():
         """Invalidate cached data due to the repository mutating."""
 
     def invalidatevolatilesets():
         pass
 
     def invalidatedirstate():
         """Invalidate the dirstate."""
 
     def invalidate(clearfilecache=False):
         pass
 
     def invalidateall():
         pass
 
     def lock(wait=True):
         """Lock the repository store and return a lock instance."""
 
     def wlock(wait=True):
         """Lock the non-store parts of the repository."""
 
     def currentwlock():
         """Return the wlock if it's held or None."""
 
     def checkcommitpatterns(wctx, vdirs, match, status, fail):
         pass
 
     def commit(text='', user=None, date=None, match=None, force=False,
                editor=False, extra=None):
         """Add a new revision to the repository."""
 
     def commitctx(ctx, error=False):
         """Commit a commitctx instance to the repository."""
 
     def destroying():
         """Inform the repository that nodes are about to be destroyed."""
 
     def destroyed():
         """Inform the repository that nodes have been destroyed."""
 
     def status(node1='.', node2=None, match=None, ignored=False,
                clean=False, unknown=False, listsubrepos=False):
         """Convenience method to call repo[x].status()."""
 
     def addpostdsstatus(ps):
         pass
 
     def postdsstatus():
         pass
 
     def clearpostdsstatus():
         pass
 
     def heads(start=None):
         """Obtain list of nodes that are DAG heads."""
 
     def branchheads(branch=None, start=None, closed=False):
         pass
 
     def branches(nodes):
         pass
 
     def between(pairs):
         pass
 
     def checkpush(pushop):
         pass
 
     prepushoutgoinghooks = interfaceutil.Attribute(
         """util.hooks instance.""")
 
     def pushkey(namespace, key, old, new):
         pass
 
     def listkeys(namespace):
         pass
 
     def debugwireargs(one, two, three=None, four=None, five=None):
         pass
 
     def savecommitmessage(text):
         pass
 
 class completelocalrepository(ilocalrepositorymain,
                               ilocalrepositoryfilestorage):
     """Complete interface for a local repository."""
 
 class iwireprotocolcommandcacher(interfaceutil.Interface):
     """Represents a caching backend for wire protocol commands.
 
     Wire protocol version 2 supports transparent caching of many commands.
     To leverage this caching, servers can activate objects that cache
     command responses. Objects handle both cache writing and reading.
     This interface defines how that response caching mechanism works.
 
     Wire protocol version 2 commands emit a series of objects that are
     serialized and sent to the client. The caching layer exists between
     the invocation of the command function and the sending of its output
     objects to an output layer.
 
     Instances of this interface represent a binding to a cache that
     can serve a response (in place of calling a command function) and/or
     write responses to a cache for subsequent use.
 
     When a command request arrives, the following happens with regards
     to this interface:
 
     1. The server determines whether the command request is cacheable.
     2. If it is, an instance of this interface is spawned.
     3. The cacher is activated in a context manager (``__enter__`` is called).
     4. A cache *key* for that request is derived. This will call the
        instance's ``adjustcachekeystate()`` method so the derivation
        can be influenced.
     5. The cacher is informed of the derived cache key via a call to
        ``setcachekey()``.
     6. The cacher's ``lookup()`` method is called to test for presence of
        the derived key in the cache.
     7. If ``lookup()`` returns a hit, that cached result is used in place
        of invoking the command function. ``__exit__`` is called and the instance
        is discarded.
     8. The command function is invoked.
     9. ``onobject()`` is called for each object emitted by the command
        function.
     10. After the final object is seen, ``onfinished()`` is called.
     11. ``__exit__`` is called to signal the end of use of the instance.
 
     Cache *key* derivation can be influenced by the instance.
 
     Cache keys are initially derived by a deterministic representation of
     the command request. This includes the command name, arguments, protocol
     version, etc. This initial key derivation is performed by CBOR-encoding a
     data structure and feeding that output into a hasher.
 
     Instances of this interface can influence this initial key derivation
     via ``adjustcachekeystate()``.
 
     The instance is informed of the derived cache key via a call to
     ``setcachekey()``. The instance must store the key locally so it can
     be consulted on subsequent operations that may require it.
 
     When constructed, the instance has access to a callable that can be used
     for encoding response objects. This callable receives as its single
     argument an object emitted by a command function. It returns an iterable
     of bytes chunks representing the encoded object. Unless the cacher is
     caching native Python objects in memory or has a way of reconstructing
     the original Python objects, implementations typically call this function
     to produce bytes from the output objects and then store those bytes in
     the cache. When it comes time to re-emit those bytes, they are wrapped
     in a ``wireprototypes.encodedresponse`` instance to tell the output
     layer that they are pre-encoded.
 
     When receiving the objects emitted by the command function, instances
     can choose what to do with those objects. The simplest thing to do is
     re-emit the original objects. They will be forwarded to the output
     layer and will be processed as if the cacher did not exist.
 
     Implementations could also choose to not emit objects - instead locally
     buffering objects or their encoded representation. They could then emit
     a single "coalesced" object when ``onfinished()`` is called. In
     this way, the implementation would function as a filtering layer of
     sorts.
 
     When caching objects, typically the encoded form of the object will
     be stored. Keep in mind that if the original object is forwarded to
     the output layer, it will need to be encoded there as well. For large
     output, this redundant encoding could add overhead. Implementations
     could wrap the encoded object data in ``wireprototypes.encodedresponse``
     instances to avoid this overhead.
     """
     def __enter__():
         """Marks the instance as active.
 
         Should return self.
         """
 
     def __exit__(exctype, excvalue, exctb):
         """Called when cacher is no longer used.
 
         This can be used by implementations to perform cleanup actions (e.g.
         disconnecting network sockets, aborting a partially cached response.
         """
 
     def adjustcachekeystate(state):
         """Influences cache key derivation by adjusting state to derive key.
 
         A dict defining the state used to derive the cache key is passed.
 
         Implementations can modify this dict to record additional state that
         is wanted to influence key derivation.
 
         Implementations are *highly* encouraged to not modify or delete
         existing keys.
         """
 
     def setcachekey(key):
         """Record the derived cache key for this request.
 
         Instances may mutate the key for internal usage, as desired. e.g.
         instances may wish to prepend the repo name, introduce path
         components for filesystem or URL addressing, etc. Behavior is up to
         the cache.
 
         Returns a bool indicating if the request is cacheable by this
         instance.
         """
 
     def lookup():
         """Attempt to resolve an entry in the cache.
 
         The instance is instructed to look for the cache key that it was
         informed about via the call to ``setcachekey()``.
 
         If there's no cache hit or the cacher doesn't wish to use the cached
         entry, ``None`` should be returned.
 
         Else, a dict defining the cached result should be returned. The
         dict may have the following keys:
 
         objs
            An iterable of objects that should be sent to the client. That
            iterable of objects is expected to be what the command function
            would return if invoked or an equivalent representation thereof.
         """
 
     def onobject(obj):
         """Called when a new object is emitted from the command function.
 
         Receives as its argument the object that was emitted from the
         command function.
 
         This method returns an iterator of objects to forward to the output
         layer. The easiest implementation is a generator that just
         ``yield obj``.
         """
 
     def onfinished():
         """Called after all objects have been emitted from the command function.
 
         Implementations should return an iterator of objects to forward to
         the output layer.
 
         This method can be a generator.
         """

mercurial/testing/storage.py

@@ -1,1331 +1,1345
 # storage.py - Testing of storage primitives.
 #
 # 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.
 
 from __future__ import absolute_import
 
 import unittest
 
 from ..node import (
     hex,
     nullid,
     nullrev,
 )
 from .. import (
     error,
     mdiff,
     repository,
 )
 from ..utils import (
     storageutil,
 )
 
 class basetestcase(unittest.TestCase):
     if not getattr(unittest.TestCase, r'assertRaisesRegex', False):
         assertRaisesRegex = (# camelcase-required
             unittest.TestCase.assertRaisesRegexp)
 
 class ifileindextests(basetestcase):
     """Generic tests for the ifileindex interface.
 
     All file storage backends for index data should conform to the tests in this
     class.
 
     Use ``makeifileindextests()`` to create an instance of this type.
     """
     def testempty(self):
         f = self._makefilefn()
         self.assertEqual(len(f), 0, 'new file store has 0 length by default')
         self.assertEqual(list(f), [], 'iter yields nothing by default')
 
         gen = iter(f)
         with self.assertRaises(StopIteration):
             next(gen)
 
+        self.assertFalse(f.hasnode(None))
+        self.assertFalse(f.hasnode(0))
+        self.assertFalse(f.hasnode(nullrev))
+        self.assertFalse(f.hasnode(nullid))
+        self.assertFalse(f.hasnode(b'0'))
+        self.assertFalse(f.hasnode(b'a' * 20))
+
         # revs() should evaluate to an empty list.
         self.assertEqual(list(f.revs()), [])
 
         revs = iter(f.revs())
         with self.assertRaises(StopIteration):
             next(revs)
 
         self.assertEqual(list(f.revs(start=20)), [])
 
         # parents() and parentrevs() work with nullid/nullrev.
         self.assertEqual(f.parents(nullid), (nullid, nullid))
         self.assertEqual(f.parentrevs(nullrev), (nullrev, nullrev))
 
         with self.assertRaises(error.LookupError):
             f.parents(b'\x01' * 20)
 
         for i in range(-5, 5):
             if i == nullrev:
                 continue
 
             with self.assertRaises(IndexError):
                 f.parentrevs(i)
 
         # nullid/nullrev lookup always works.
         self.assertEqual(f.rev(nullid), nullrev)
         self.assertEqual(f.node(nullrev), nullid)
 
         with self.assertRaises(error.LookupError):
             f.rev(b'\x01' * 20)
 
         for i in range(-5, 5):
             if i == nullrev:
                 continue
 
             with self.assertRaises(IndexError):
                 f.node(i)
 
         self.assertEqual(f.lookup(nullid), nullid)
         self.assertEqual(f.lookup(nullrev), nullid)
         self.assertEqual(f.lookup(hex(nullid)), nullid)
         self.assertEqual(f.lookup(b'%d' % nullrev), nullid)
 
         with self.assertRaises(error.LookupError):
             f.lookup(b'badvalue')
 
         with self.assertRaises(error.LookupError):
             f.lookup(hex(nullid)[0:12])
 
         with self.assertRaises(error.LookupError):
             f.lookup(b'-2')
 
         with self.assertRaises(error.LookupError):
             f.lookup(b'0')
 
         with self.assertRaises(error.LookupError):
             f.lookup(b'1')
 
         with self.assertRaises(error.LookupError):
             f.lookup(b'11111111111111111111111111111111111111')
 
         for i in range(-5, 5):
             if i == nullrev:
                 continue
 
             with self.assertRaises(LookupError):
                 f.lookup(i)
 
         self.assertEqual(f.linkrev(nullrev), nullrev)
 
         for i in range(-5, 5):
             if i == nullrev:
                 continue
 
             with self.assertRaises(IndexError):
                 f.linkrev(i)
 
         self.assertFalse(f.iscensored(nullrev))
 
         for i in range(-5, 5):
             if i == nullrev:
                 continue
 
             with self.assertRaises(IndexError):
                 f.iscensored(i)
 
         self.assertEqual(list(f.commonancestorsheads(nullid, nullid)), [])
 
         with self.assertRaises(ValueError):
             self.assertEqual(list(f.descendants([])), [])
 
         self.assertEqual(list(f.descendants([nullrev])), [])
 
         self.assertEqual(f.heads(), [nullid])
         self.assertEqual(f.heads(nullid), [nullid])
         self.assertEqual(f.heads(None, [nullid]), [nullid])
         self.assertEqual(f.heads(nullid, [nullid]), [nullid])
 
         self.assertEqual(f.children(nullid), [])
 
         with self.assertRaises(error.LookupError):
             f.children(b'\x01' * 20)
 
     def testsinglerevision(self):
         f = self._makefilefn()
         with self._maketransactionfn() as tr:
             node = f.add(b'initial', None, tr, 0, nullid, nullid)
 
         self.assertEqual(len(f), 1)
         self.assertEqual(list(f), [0])
 
         gen = iter(f)
         self.assertEqual(next(gen), 0)
 
         with self.assertRaises(StopIteration):
             next(gen)
 
+        self.assertTrue(f.hasnode(node))
+        self.assertFalse(f.hasnode(hex(node)))
+        self.assertFalse(f.hasnode(nullrev))
+        self.assertFalse(f.hasnode(nullid))
+        self.assertFalse(f.hasnode(node[0:12]))
+        self.assertFalse(f.hasnode(hex(node)[0:20]))
+
         self.assertEqual(list(f.revs()), [0])
         self.assertEqual(list(f.revs(start=1)), [])
         self.assertEqual(list(f.revs(start=0)), [0])
         self.assertEqual(list(f.revs(stop=0)), [0])
         self.assertEqual(list(f.revs(stop=1)), [0])
         self.assertEqual(list(f.revs(1, 1)), [])
         # TODO buggy
         self.assertEqual(list(f.revs(1, 0)), [1, 0])
         self.assertEqual(list(f.revs(2, 0)), [2, 1, 0])
 
         self.assertEqual(f.parents(node), (nullid, nullid))
         self.assertEqual(f.parentrevs(0), (nullrev, nullrev))
 
         with self.assertRaises(error.LookupError):
             f.parents(b'\x01' * 20)
 
         with self.assertRaises(IndexError):
             f.parentrevs(1)
 
         self.assertEqual(f.rev(node), 0)
 
         with self.assertRaises(error.LookupError):
             f.rev(b'\x01' * 20)
 
         self.assertEqual(f.node(0), node)
 
         with self.assertRaises(IndexError):
             f.node(1)
 
         self.assertEqual(f.lookup(node), node)
         self.assertEqual(f.lookup(0), node)
         self.assertEqual(f.lookup(-1), nullid)
         self.assertEqual(f.lookup(b'0'), node)
         self.assertEqual(f.lookup(hex(node)), node)
 
         with self.assertRaises(error.LookupError):
             f.lookup(hex(node)[0:12])
 
         with self.assertRaises(error.LookupError):
             f.lookup(-2)
 
         with self.assertRaises(error.LookupError):
             f.lookup(b'-2')
 
         with self.assertRaises(error.LookupError):
             f.lookup(1)
 
         with self.assertRaises(error.LookupError):
             f.lookup(b'1')
 
         self.assertEqual(f.linkrev(0), 0)
 
         with self.assertRaises(IndexError):
             f.linkrev(1)
 
         self.assertFalse(f.iscensored(0))
 
         with self.assertRaises(IndexError):
             f.iscensored(1)
 
         self.assertEqual(list(f.descendants([0])), [])
 
         self.assertEqual(f.heads(), [node])
         self.assertEqual(f.heads(node), [node])
         self.assertEqual(f.heads(stop=[node]), [node])
 
         with self.assertRaises(error.LookupError):
             f.heads(stop=[b'\x01' * 20])
 
         self.assertEqual(f.children(node), [])
 
     def testmultiplerevisions(self):
         fulltext0 = b'x' * 1024
         fulltext1 = fulltext0 + b'y'
         fulltext2 = b'y' + fulltext0 + b'z'
 
         f = self._makefilefn()
         with self._maketransactionfn() as tr:
             node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)
             node1 = f.add(fulltext1, None, tr, 1, node0, nullid)
             node2 = f.add(fulltext2, None, tr, 3, node1, nullid)
 
         self.assertEqual(len(f), 3)
         self.assertEqual(list(f), [0, 1, 2])
 
         gen = iter(f)
         self.assertEqual(next(gen), 0)
         self.assertEqual(next(gen), 1)
         self.assertEqual(next(gen), 2)
 
         with self.assertRaises(StopIteration):
             next(gen)
 
         self.assertEqual(list(f.revs()), [0, 1, 2])
         self.assertEqual(list(f.revs(0)), [0, 1, 2])
         self.assertEqual(list(f.revs(1)), [1, 2])
         self.assertEqual(list(f.revs(2)), [2])
         self.assertEqual(list(f.revs(3)), [])
         self.assertEqual(list(f.revs(stop=1)), [0, 1])
         self.assertEqual(list(f.revs(stop=2)), [0, 1, 2])
         self.assertEqual(list(f.revs(stop=3)), [0, 1, 2])
         self.assertEqual(list(f.revs(2, 0)), [2, 1, 0])
         self.assertEqual(list(f.revs(2, 1)), [2, 1])
         # TODO this is wrong
         self.assertEqual(list(f.revs(3, 2)), [3, 2])
 
         self.assertEqual(f.parents(node0), (nullid, nullid))
         self.assertEqual(f.parents(node1), (node0, nullid))
         self.assertEqual(f.parents(node2), (node1, nullid))
 
         self.assertEqual(f.parentrevs(0), (nullrev, nullrev))
         self.assertEqual(f.parentrevs(1), (0, nullrev))
         self.assertEqual(f.parentrevs(2), (1, nullrev))
 
         self.assertEqual(f.rev(node0), 0)
         self.assertEqual(f.rev(node1), 1)
         self.assertEqual(f.rev(node2), 2)
 
         with self.assertRaises(error.LookupError):
             f.rev(b'\x01' * 20)
 
         self.assertEqual(f.node(0), node0)
         self.assertEqual(f.node(1), node1)
         self.assertEqual(f.node(2), node2)
 
         with self.assertRaises(IndexError):
             f.node(3)
 
         self.assertEqual(f.lookup(node0), node0)
         self.assertEqual(f.lookup(0), node0)
         self.assertEqual(f.lookup(b'0'), node0)
         self.assertEqual(f.lookup(hex(node0)), node0)
 
         self.assertEqual(f.lookup(node1), node1)
         self.assertEqual(f.lookup(1), node1)
         self.assertEqual(f.lookup(b'1'), node1)
         self.assertEqual(f.lookup(hex(node1)), node1)
 
         self.assertEqual(f.linkrev(0), 0)
         self.assertEqual(f.linkrev(1), 1)
         self.assertEqual(f.linkrev(2), 3)
 
         with self.assertRaises(IndexError):
             f.linkrev(3)
 
         self.assertFalse(f.iscensored(0))
         self.assertFalse(f.iscensored(1))
         self.assertFalse(f.iscensored(2))
 
         with self.assertRaises(IndexError):
             f.iscensored(3)
 
         self.assertEqual(f.commonancestorsheads(node1, nullid), [])
         self.assertEqual(f.commonancestorsheads(node1, node0), [node0])
         self.assertEqual(f.commonancestorsheads(node1, node1), [node1])
         self.assertEqual(f.commonancestorsheads(node0, node1), [node0])
         self.assertEqual(f.commonancestorsheads(node1, node2), [node1])
         self.assertEqual(f.commonancestorsheads(node2, node1), [node1])
 
         self.assertEqual(list(f.descendants([0])), [1, 2])
         self.assertEqual(list(f.descendants([1])), [2])
         self.assertEqual(list(f.descendants([0, 1])), [1, 2])
 
         self.assertEqual(f.heads(), [node2])
         self.assertEqual(f.heads(node0), [node2])
         self.assertEqual(f.heads(node1), [node2])
         self.assertEqual(f.heads(node2), [node2])
 
         # TODO this behavior seems wonky. Is it correct? If so, the
         # docstring for heads() should be updated to reflect desired
         # behavior.
         self.assertEqual(f.heads(stop=[node1]), [node1, node2])
         self.assertEqual(f.heads(stop=[node0]), [node0, node2])
         self.assertEqual(f.heads(stop=[node1, node2]), [node1, node2])
 
         with self.assertRaises(error.LookupError):
             f.heads(stop=[b'\x01' * 20])
 
         self.assertEqual(f.children(node0), [node1])
         self.assertEqual(f.children(node1), [node2])
         self.assertEqual(f.children(node2), [])
 
     def testmultipleheads(self):
         f = self._makefilefn()
 
         with self._maketransactionfn() as tr:
             node0 = f.add(b'0', None, tr, 0, nullid, nullid)
             node1 = f.add(b'1', None, tr, 1, node0, nullid)
             node2 = f.add(b'2', None, tr, 2, node1, nullid)
             node3 = f.add(b'3', None, tr, 3, node0, nullid)
             node4 = f.add(b'4', None, tr, 4, node3, nullid)
             node5 = f.add(b'5', None, tr, 5, node0, nullid)
 
         self.assertEqual(len(f), 6)
 
         self.assertEqual(list(f.descendants([0])), [1, 2, 3, 4, 5])
         self.assertEqual(list(f.descendants([1])), [2])
         self.assertEqual(list(f.descendants([2])), [])
         self.assertEqual(list(f.descendants([3])), [4])
         self.assertEqual(list(f.descendants([0, 1])), [1, 2, 3, 4, 5])
         self.assertEqual(list(f.descendants([1, 3])), [2, 4])
 
         self.assertEqual(f.heads(), [node2, node4, node5])
         self.assertEqual(f.heads(node0), [node2, node4, node5])
         self.assertEqual(f.heads(node1), [node2])
         self.assertEqual(f.heads(node2), [node2])
         self.assertEqual(f.heads(node3), [node4])
         self.assertEqual(f.heads(node4), [node4])
         self.assertEqual(f.heads(node5), [node5])
 
         # TODO this seems wrong.
         self.assertEqual(f.heads(stop=[node0]), [node0, node2, node4, node5])
         self.assertEqual(f.heads(stop=[node1]), [node1, node2, node4, node5])
 
         self.assertEqual(f.children(node0), [node1, node3, node5])
         self.assertEqual(f.children(node1), [node2])
         self.assertEqual(f.children(node2), [])
         self.assertEqual(f.children(node3), [node4])
         self.assertEqual(f.children(node4), [])
         self.assertEqual(f.children(node5), [])
 
 class ifiledatatests(basetestcase):
     """Generic tests for the ifiledata interface.
 
     All file storage backends for data should conform to the tests in this
     class.
 
     Use ``makeifiledatatests()`` to create an instance of this type.
     """
     def testempty(self):
         f = self._makefilefn()
 
         self.assertEqual(f.storageinfo(), {})
         self.assertEqual(f.storageinfo(revisionscount=True, trackedsize=True),
                          {'revisionscount': 0, 'trackedsize': 0})
 
         self.assertEqual(f.size(nullrev), 0)
 
         for i in range(-5, 5):
             if i == nullrev:
                 continue
 
             with self.assertRaises(IndexError):
                 f.size(i)
 
         self.assertEqual(f.revision(nullid), b'')
         self.assertEqual(f.revision(nullid, raw=True), b'')
 
         with self.assertRaises(error.LookupError):
             f.revision(b'\x01' * 20)
 
         self.assertEqual(f.read(nullid), b'')
 
         with self.assertRaises(error.LookupError):
             f.read(b'\x01' * 20)
 
         self.assertFalse(f.renamed(nullid))
 
         with self.assertRaises(error.LookupError):
             f.read(b'\x01' * 20)
 
         self.assertTrue(f.cmp(nullid, b''))
         self.assertTrue(f.cmp(nullid, b'foo'))
 
         with self.assertRaises(error.LookupError):
             f.cmp(b'\x01' * 20, b'irrelevant')
 
         # Emitting empty list is an empty generator.
         gen = f.emitrevisions([])
         with self.assertRaises(StopIteration):
             next(gen)
 
         # Emitting null node yields nothing.
         gen = f.emitrevisions([nullid])
         with self.assertRaises(StopIteration):
             next(gen)
 
         # Requesting unknown node fails.
         with self.assertRaises(error.LookupError):
             list(f.emitrevisions([b'\x01' * 20]))
 
     def testsinglerevision(self):
         fulltext = b'initial'
 
         f = self._makefilefn()
         with self._maketransactionfn() as tr:
             node = f.add(fulltext, None, tr, 0, nullid, nullid)
 
         self.assertEqual(f.storageinfo(), {})
         self.assertEqual(f.storageinfo(revisionscount=True, trackedsize=True),
                          {'revisionscount': 1, 'trackedsize': len(fulltext)})
 
         self.assertEqual(f.size(0), len(fulltext))
 
         with self.assertRaises(IndexError):
             f.size(1)
 
         self.assertEqual(f.revision(node), fulltext)
         self.assertEqual(f.revision(node, raw=True), fulltext)
 
         self.assertEqual(f.read(node), fulltext)
 
         self.assertFalse(f.renamed(node))
 
         self.assertFalse(f.cmp(node, fulltext))
         self.assertTrue(f.cmp(node, fulltext + b'extra'))
 
         # Emitting a single revision works.
         gen = f.emitrevisions([node])
         rev = next(gen)
 
         self.assertEqual(rev.node, node)
         self.assertEqual(rev.p1node, nullid)
         self.assertEqual(rev.p2node, nullid)
         self.assertIsNone(rev.linknode)
         self.assertEqual(rev.basenode, nullid)
         self.assertIsNone(rev.baserevisionsize)
         self.assertIsNone(rev.revision)
         self.assertIsNone(rev.delta)
 
         with self.assertRaises(StopIteration):
             next(gen)
 
         # Requesting revision data works.
         gen = f.emitrevisions([node], revisiondata=True)
         rev = next(gen)
 
         self.assertEqual(rev.node, node)
         self.assertEqual(rev.p1node, nullid)
         self.assertEqual(rev.p2node, nullid)
         self.assertIsNone(rev.linknode)
         self.assertEqual(rev.basenode, nullid)
         self.assertIsNone(rev.baserevisionsize)
         self.assertEqual(rev.revision, fulltext)
         self.assertIsNone(rev.delta)
 
         with self.assertRaises(StopIteration):
             next(gen)
 
         # Emitting an unknown node after a known revision results in error.
         with self.assertRaises(error.LookupError):
             list(f.emitrevisions([node, b'\x01' * 20]))
 
     def testmultiplerevisions(self):
         fulltext0 = b'x' * 1024
         fulltext1 = fulltext0 + b'y'
         fulltext2 = b'y' + fulltext0 + b'z'
 
         f = self._makefilefn()
         with self._maketransactionfn() as tr:
             node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)
             node1 = f.add(fulltext1, None, tr, 1, node0, nullid)
             node2 = f.add(fulltext2, None, tr, 3, node1, nullid)
 
         self.assertEqual(f.storageinfo(), {})
         self.assertEqual(
             f.storageinfo(revisionscount=True, trackedsize=True),
             {
                 'revisionscount': 3,
                 'trackedsize': len(fulltext0) + len(fulltext1) + len(fulltext2),
             })
 
         self.assertEqual(f.size(0), len(fulltext0))
         self.assertEqual(f.size(1), len(fulltext1))
         self.assertEqual(f.size(2), len(fulltext2))
 
         with self.assertRaises(IndexError):
             f.size(3)
 
         self.assertEqual(f.revision(node0), fulltext0)
         self.assertEqual(f.revision(node0, raw=True), fulltext0)
         self.assertEqual(f.revision(node1), fulltext1)
         self.assertEqual(f.revision(node1, raw=True), fulltext1)
         self.assertEqual(f.revision(node2), fulltext2)
         self.assertEqual(f.revision(node2, raw=True), fulltext2)
 
         with self.assertRaises(error.LookupError):
             f.revision(b'\x01' * 20)
 
         self.assertEqual(f.read(node0), fulltext0)
         self.assertEqual(f.read(node1), fulltext1)
         self.assertEqual(f.read(node2), fulltext2)
 
         with self.assertRaises(error.LookupError):
             f.read(b'\x01' * 20)
 
         self.assertFalse(f.renamed(node0))
         self.assertFalse(f.renamed(node1))
         self.assertFalse(f.renamed(node2))
 
         with self.assertRaises(error.LookupError):
             f.renamed(b'\x01' * 20)
 
         self.assertFalse(f.cmp(node0, fulltext0))
         self.assertFalse(f.cmp(node1, fulltext1))
         self.assertFalse(f.cmp(node2, fulltext2))
 
         self.assertTrue(f.cmp(node1, fulltext0))
         self.assertTrue(f.cmp(node2, fulltext1))
 
         with self.assertRaises(error.LookupError):
             f.cmp(b'\x01' * 20, b'irrelevant')
 
         # Nodes should be emitted in order.
         gen = f.emitrevisions([node0, node1, node2], revisiondata=True)
 
         rev = next(gen)
 
         self.assertEqual(rev.node, node0)
         self.assertEqual(rev.p1node, nullid)
         self.assertEqual(rev.p2node, nullid)
         self.assertIsNone(rev.linknode)
         self.assertEqual(rev.basenode, nullid)
         self.assertIsNone(rev.baserevisionsize)
         self.assertEqual(rev.revision, fulltext0)
         self.assertIsNone(rev.delta)
 
         rev = next(gen)
 
         self.assertEqual(rev.node, node1)
         self.assertEqual(rev.p1node, node0)
         self.assertEqual(rev.p2node, nullid)
         self.assertIsNone(rev.linknode)
         self.assertEqual(rev.basenode, node0)
         self.assertIsNone(rev.baserevisionsize)
         self.assertIsNone(rev.revision)
         self.assertEqual(rev.delta,
                          b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' +
                          fulltext1)
 
         rev = next(gen)
 
         self.assertEqual(rev.node, node2)
         self.assertEqual(rev.p1node, node1)
         self.assertEqual(rev.p2node, nullid)
         self.assertIsNone(rev.linknode)
         self.assertEqual(rev.basenode, node1)
         self.assertIsNone(rev.baserevisionsize)
         self.assertIsNone(rev.revision)
         self.assertEqual(rev.delta,
                          b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' +
                          fulltext2)
 
         with self.assertRaises(StopIteration):
             next(gen)
 
         # Request not in DAG order is reordered to be in DAG order.
         gen = f.emitrevisions([node2, node1, node0], revisiondata=True)
 
         rev = next(gen)
 
         self.assertEqual(rev.node, node0)
         self.assertEqual(rev.p1node, nullid)
         self.assertEqual(rev.p2node, nullid)
         self.assertIsNone(rev.linknode)
         self.assertEqual(rev.basenode, nullid)
         self.assertIsNone(rev.baserevisionsize)
         self.assertEqual(rev.revision, fulltext0)
         self.assertIsNone(rev.delta)
 
         rev = next(gen)
 
         self.assertEqual(rev.node, node1)
         self.assertEqual(rev.p1node, node0)
         self.assertEqual(rev.p2node, nullid)
         self.assertIsNone(rev.linknode)
         self.assertEqual(rev.basenode, node0)
         self.assertIsNone(rev.baserevisionsize)
         self.assertIsNone(rev.revision)
         self.assertEqual(rev.delta,
                          b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' +
                          fulltext1)
 
         rev = next(gen)
 
         self.assertEqual(rev.node, node2)
         self.assertEqual(rev.p1node, node1)
         self.assertEqual(rev.p2node, nullid)
         self.assertIsNone(rev.linknode)
         self.assertEqual(rev.basenode, node1)
         self.assertIsNone(rev.baserevisionsize)
         self.assertIsNone(rev.revision)
         self.assertEqual(rev.delta,
                          b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' +
                          fulltext2)
 
         with self.assertRaises(StopIteration):
             next(gen)
 
         # Unrecognized nodesorder value raises ProgrammingError.
         with self.assertRaises(error.ProgrammingError):
             list(f.emitrevisions([], nodesorder='bad'))
 
         # nodesorder=storage is recognized. But we can't test it thoroughly
         # because behavior is storage-dependent.
         res = list(f.emitrevisions([node2, node1, node0],
                                          nodesorder='storage'))
         self.assertEqual(len(res), 3)
         self.assertEqual({o.node for o in res}, {node0, node1, node2})
 
         # nodesorder=nodes forces the order.
         gen = f.emitrevisions([node2, node0], nodesorder='nodes',
                               revisiondata=True)
 
         rev = next(gen)
         self.assertEqual(rev.node, node2)
         self.assertEqual(rev.p1node, node1)
         self.assertEqual(rev.p2node, nullid)
         self.assertEqual(rev.basenode, nullid)
         self.assertIsNone(rev.baserevisionsize)
         self.assertEqual(rev.revision, fulltext2)
         self.assertIsNone(rev.delta)
 
         rev = next(gen)
         self.assertEqual(rev.node, node0)
         self.assertEqual(rev.p1node, nullid)
         self.assertEqual(rev.p2node, nullid)
         # Delta behavior is storage dependent, so we can't easily test it.
 
         with self.assertRaises(StopIteration):
             next(gen)
 
         # assumehaveparentrevisions=False (the default) won't send a delta for
         # the first revision.
         gen = f.emitrevisions({node2, node1}, revisiondata=True)
 
         rev = next(gen)
         self.assertEqual(rev.node, node1)
         self.assertEqual(rev.p1node, node0)
         self.assertEqual(rev.p2node, nullid)
         self.assertEqual(rev.basenode, nullid)
         self.assertIsNone(rev.baserevisionsize)
         self.assertEqual(rev.revision, fulltext1)
         self.assertIsNone(rev.delta)
 
         rev = next(gen)
         self.assertEqual(rev.node, node2)
         self.assertEqual(rev.p1node, node1)
         self.assertEqual(rev.p2node, nullid)
         self.assertEqual(rev.basenode, node1)
         self.assertIsNone(rev.baserevisionsize)
         self.assertIsNone(rev.revision)
         self.assertEqual(rev.delta,
                          b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' +
                          fulltext2)
 
         with self.assertRaises(StopIteration):
             next(gen)
 
         # assumehaveparentrevisions=True allows delta against initial revision.
         gen = f.emitrevisions([node2, node1],
                               revisiondata=True, assumehaveparentrevisions=True)
 
         rev = next(gen)
         self.assertEqual(rev.node, node1)
         self.assertEqual(rev.p1node, node0)
         self.assertEqual(rev.p2node, nullid)
         self.assertEqual(rev.basenode, node0)
         self.assertIsNone(rev.baserevisionsize)
         self.assertIsNone(rev.revision)
         self.assertEqual(rev.delta,
                          b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' +
                          fulltext1)
 
         # forceprevious=True forces a delta against the previous revision.
         # Special case for initial revision.
         gen = f.emitrevisions([node0], revisiondata=True, deltaprevious=True)
 
         rev = next(gen)
         self.assertEqual(rev.node, node0)
         self.assertEqual(rev.p1node, nullid)
         self.assertEqual(rev.p2node, nullid)
         self.assertEqual(rev.basenode, nullid)
         self.assertIsNone(rev.baserevisionsize)
         self.assertIsNone(rev.revision)
         self.assertEqual(rev.delta,
                          b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' +
                          fulltext0)
 
         with self.assertRaises(StopIteration):
             next(gen)
 
         gen = f.emitrevisions([node0, node2], revisiondata=True,
                               deltaprevious=True)
 
         rev = next(gen)
         self.assertEqual(rev.node, node0)
         self.assertEqual(rev.p1node, nullid)
         self.assertEqual(rev.p2node, nullid)
         self.assertEqual(rev.basenode, nullid)
         self.assertIsNone(rev.baserevisionsize)
         self.assertIsNone(rev.revision)
         self.assertEqual(rev.delta,
                          b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' +
                          fulltext0)
 
         rev = next(gen)
         self.assertEqual(rev.node, node2)
         self.assertEqual(rev.p1node, node1)
         self.assertEqual(rev.p2node, nullid)
         self.assertEqual(rev.basenode, node0)
 
         with self.assertRaises(StopIteration):
             next(gen)
 
     def testrenamed(self):
         fulltext0 = b'foo'
         fulltext1 = b'bar'
         fulltext2 = b'baz'
 
         meta1 = {
             b'copy': b'source0',
             b'copyrev': b'a' * 40,
         }
 
         meta2 = {
             b'copy': b'source1',
             b'copyrev': b'b' * 40,
         }
 
         stored1 = b''.join([
             b'\x01\ncopy: source0\n',
             b'copyrev: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n\x01\n',
             fulltext1,
         ])
 
         stored2 = b''.join([
             b'\x01\ncopy: source1\n',
             b'copyrev: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n\x01\n',
             fulltext2,
         ])
 
         f = self._makefilefn()
         with self._maketransactionfn() as tr:
             node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)
             node1 = f.add(fulltext1, meta1, tr, 1, node0, nullid)
             node2 = f.add(fulltext2, meta2, tr, 2, nullid, nullid)
 
         # Metadata header isn't recognized when parent isn't nullid.
         self.assertEqual(f.size(1), len(stored1))
         self.assertEqual(f.size(2), len(fulltext2))
 
         self.assertEqual(f.revision(node1), stored1)
         self.assertEqual(f.revision(node1, raw=True), stored1)
         self.assertEqual(f.revision(node2), stored2)
         self.assertEqual(f.revision(node2, raw=True), stored2)
 
         self.assertEqual(f.read(node1), fulltext1)
         self.assertEqual(f.read(node2), fulltext2)
 
         # Returns False when first parent is set.
         self.assertFalse(f.renamed(node1))
         self.assertEqual(f.renamed(node2), (b'source1', b'\xbb' * 20))
 
         self.assertTrue(f.cmp(node1, fulltext1))
         self.assertTrue(f.cmp(node1, stored1))
         self.assertFalse(f.cmp(node2, fulltext2))
         self.assertTrue(f.cmp(node2, stored2))
 
     def testmetadataprefix(self):
         # Content with metadata prefix has extra prefix inserted in storage.
         fulltext0 = b'\x01\nfoo'
         stored0 = b'\x01\n\x01\n\x01\nfoo'
 
         fulltext1 = b'\x01\nbar'
         meta1 = {
             b'copy': b'source0',
             b'copyrev': b'b' * 40,
         }
         stored1 = b''.join([
             b'\x01\ncopy: source0\n',
             b'copyrev: %s\n' % (b'b' * 40),
             b'\x01\n\x01\nbar',
         ])
 
         f = self._makefilefn()
         with self._maketransactionfn() as tr:
             node0 = f.add(fulltext0, {}, tr, 0, nullid, nullid)
             node1 = f.add(fulltext1, meta1, tr, 1, nullid, nullid)
 
         # TODO this is buggy.
         self.assertEqual(f.size(0), len(fulltext0) + 4)
 
         self.assertEqual(f.size(1), len(fulltext1))
 
         self.assertEqual(f.revision(node0), stored0)
         self.assertEqual(f.revision(node0, raw=True), stored0)
 
         self.assertEqual(f.revision(node1), stored1)
         self.assertEqual(f.revision(node1, raw=True), stored1)
 
         self.assertEqual(f.read(node0), fulltext0)
         self.assertEqual(f.read(node1), fulltext1)
 
         self.assertFalse(f.cmp(node0, fulltext0))
         self.assertTrue(f.cmp(node0, stored0))
 
         self.assertFalse(f.cmp(node1, fulltext1))
         self.assertTrue(f.cmp(node1, stored0))
 
     def testbadnoderead(self):
         f = self._makefilefn()
 
         fulltext0 = b'foo\n' * 30
         fulltext1 = fulltext0 + b'bar\n'
 
         with self._maketransactionfn() as tr:
             node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)
             node1 = b'\xaa' * 20
 
             self._addrawrevisionfn(f, tr, node1, node0, nullid, 1,
                                    rawtext=fulltext1)
 
         self.assertEqual(len(f), 2)
         self.assertEqual(f.parents(node1), (node0, nullid))
 
         # revision() raises since it performs hash verification.
         with self.assertRaises(error.StorageError):
             f.revision(node1)
 
         # raw=True still verifies because there are no special storage
         # settings.
         with self.assertRaises(error.StorageError):
             f.revision(node1, raw=True)
 
         # read() behaves like revision().
         with self.assertRaises(error.StorageError):
             f.read(node1)
 
         # We can't test renamed() here because some backends may not require
         # reading/validating the fulltext to return rename metadata.
 
     def testbadnoderevisionraw(self):
         # Like above except we test revision(raw=True) first to isolate
         # revision caching behavior.
         f = self._makefilefn()
 
         fulltext0 = b'foo\n' * 30
         fulltext1 = fulltext0 + b'bar\n'
 
         with self._maketransactionfn() as tr:
             node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)
             node1 = b'\xaa' * 20
 
             self._addrawrevisionfn(f, tr, node1, node0, nullid, 1,
                                    rawtext=fulltext1)
 
         with self.assertRaises(error.StorageError):
             f.revision(node1, raw=True)
 
         with self.assertRaises(error.StorageError):
             f.revision(node1, raw=True)
 
     def testbadnoderevisionraw(self):
         # Like above except we test read() first to isolate revision caching
         # behavior.
         f = self._makefilefn()
 
         fulltext0 = b'foo\n' * 30
         fulltext1 = fulltext0 + b'bar\n'
 
         with self._maketransactionfn() as tr:
             node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)
             node1 = b'\xaa' * 20
 
             self._addrawrevisionfn(f, tr, node1, node0, nullid, 1,
                                    rawtext=fulltext1)
 
         with self.assertRaises(error.StorageError):
             f.read(node1)
 
         with self.assertRaises(error.StorageError):
             f.read(node1)
 
     def testbadnodedelta(self):
         f = self._makefilefn()
 
         fulltext0 = b'foo\n' * 31
         fulltext1 = fulltext0 + b'bar\n'
         fulltext2 = fulltext1 + b'baz\n'
 
         with self._maketransactionfn() as tr:
             node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)
             node1 = b'\xaa' * 20
 
             self._addrawrevisionfn(f, tr, node1, node0, nullid, 1,
                                    rawtext=fulltext1)
 
         with self.assertRaises(error.StorageError):
             f.read(node1)
 
         node2 = storageutil.hashrevisionsha1(fulltext2, node1, nullid)
 
         with self._maketransactionfn() as tr:
             delta = mdiff.textdiff(fulltext1, fulltext2)
             self._addrawrevisionfn(f, tr, node2, node1, nullid,
                                    2, delta=(1, delta))
 
         self.assertEqual(len(f), 3)
 
         # Assuming a delta is stored, we shouldn't need to validate node1 in
         # order to retrieve node2.
         self.assertEqual(f.read(node2), fulltext2)
 
     def testcensored(self):
         f = self._makefilefn()
 
         stored1 = storageutil.packmeta({
             b'censored': b'tombstone',
         }, b'')
 
         with self._maketransactionfn() as tr:
             node0 = f.add(b'foo', None, tr, 0, nullid, nullid)
 
             # The node value doesn't matter since we can't verify it.
             node1 = b'\xbb' * 20
 
             self._addrawrevisionfn(f, tr, node1, node0, nullid, 1, stored1,
                                    censored=True)
 
         self.assertTrue(f.iscensored(1))
 
         with self.assertRaises(error.CensoredNodeError):
             f.revision(1)
 
         with self.assertRaises(error.CensoredNodeError):
             f.revision(1, raw=True)
 
         with self.assertRaises(error.CensoredNodeError):
             f.read(1)
 
     def testcensoredrawrevision(self):
         # Like above, except we do the revision(raw=True) request first to
         # isolate revision caching behavior.
 
         f = self._makefilefn()
 
         stored1 = storageutil.packmeta({
             b'censored': b'tombstone',
         }, b'')
 
         with self._maketransactionfn() as tr:
             node0 = f.add(b'foo', None, tr, 0, nullid, nullid)
 
             # The node value doesn't matter since we can't verify it.
             node1 = b'\xbb' * 20
 
             self._addrawrevisionfn(f, tr, node1, node0, nullid, 1, stored1,
                                    censored=True)
 
         with self.assertRaises(error.CensoredNodeError):
             f.revision(1, raw=True)
 
 class ifilemutationtests(basetestcase):
     """Generic tests for the ifilemutation interface.
 
     All file storage backends that support writing should conform to this
     interface.
 
     Use ``makeifilemutationtests()`` to create an instance of this type.
     """
     def testaddnoop(self):
         f = self._makefilefn()
         with self._maketransactionfn() as tr:
             node0 = f.add(b'foo', None, tr, 0, nullid, nullid)
             node1 = f.add(b'foo', None, tr, 0, nullid, nullid)
             # Varying by linkrev shouldn't impact hash.
             node2 = f.add(b'foo', None, tr, 1, nullid, nullid)
 
         self.assertEqual(node1, node0)
         self.assertEqual(node2, node0)
         self.assertEqual(len(f), 1)
 
     def testaddrevisionbadnode(self):
         f = self._makefilefn()
         with self._maketransactionfn() as tr:
             # Adding a revision with bad node value fails.
             with self.assertRaises(error.StorageError):
                 f.addrevision(b'foo', tr, 0, nullid, nullid, node=b'\x01' * 20)
 
     def testaddrevisionunknownflag(self):
         f = self._makefilefn()
         with self._maketransactionfn() as tr:
             for i in range(15, 0, -1):
                 if (1 << i) & ~repository.REVISION_FLAGS_KNOWN:
                     flags = 1 << i
                     break
 
             with self.assertRaises(error.StorageError):
                 f.addrevision(b'foo', tr, 0, nullid, nullid, flags=flags)
 
     def testaddgroupsimple(self):
         f = self._makefilefn()
 
         callbackargs = []
         def cb(*args, **kwargs):
             callbackargs.append((args, kwargs))
 
         def linkmapper(node):
             return 0
 
         with self._maketransactionfn() as tr:
             nodes = f.addgroup([], None, tr, addrevisioncb=cb)
 
         self.assertEqual(nodes, [])
         self.assertEqual(callbackargs, [])
         self.assertEqual(len(f), 0)
 
         fulltext0 = b'foo'
         delta0 = mdiff.trivialdiffheader(len(fulltext0)) + fulltext0
 
         with self._maketransactionfn() as tr:
             node0 = f.add(fulltext0, None, tr, 0, nullid, nullid)
 
         f = self._makefilefn()
 
         deltas = [
             (node0, nullid, nullid, nullid, nullid, delta0, 0),
         ]
 
         with self._maketransactionfn() as tr:
             nodes = f.addgroup(deltas, linkmapper, tr, addrevisioncb=cb)
 
         self.assertEqual(nodes, [
             b'\x49\xd8\xcb\xb1\x5c\xe2\x57\x92\x04\x47'
             b'\x00\x6b\x46\x97\x8b\x7a\xf9\x80\xa9\x79'])
 
         self.assertEqual(len(callbackargs), 1)
         self.assertEqual(callbackargs[0][0][1], nodes[0])
 
         self.assertEqual(list(f.revs()), [0])
         self.assertEqual(f.rev(nodes[0]), 0)
         self.assertEqual(f.node(0), nodes[0])
 
     def testaddgroupmultiple(self):
         f = self._makefilefn()
 
         fulltexts = [
             b'foo',
             b'bar',
             b'x' * 1024,
         ]
 
         nodes = []
         with self._maketransactionfn() as tr:
             for fulltext in fulltexts:
                 nodes.append(f.add(fulltext, None, tr, 0, nullid, nullid))
 
         f = self._makefilefn()
         deltas = []
         for i, fulltext in enumerate(fulltexts):
             delta = mdiff.trivialdiffheader(len(fulltext)) + fulltext
 
             deltas.append((nodes[i], nullid, nullid, nullid, nullid, delta, 0))
 
         with self._maketransactionfn() as tr:
             self.assertEqual(f.addgroup(deltas, lambda x: 0, tr), nodes)
 
         self.assertEqual(len(f), len(deltas))
         self.assertEqual(list(f.revs()), [0, 1, 2])
         self.assertEqual(f.rev(nodes[0]), 0)
         self.assertEqual(f.rev(nodes[1]), 1)
         self.assertEqual(f.rev(nodes[2]), 2)
         self.assertEqual(f.node(0), nodes[0])
         self.assertEqual(f.node(1), nodes[1])
         self.assertEqual(f.node(2), nodes[2])
 
     def testdeltaagainstcensored(self):
         # Attempt to apply a delta made against a censored revision.
         f = self._makefilefn()
 
         stored1 = storageutil.packmeta({
             b'censored': b'tombstone',
         }, b'')
 
         with self._maketransactionfn() as tr:
             node0 = f.add(b'foo\n' * 30, None, tr, 0, nullid, nullid)
 
             # The node value doesn't matter since we can't verify it.
             node1 = b'\xbb' * 20
 
             self._addrawrevisionfn(f, tr, node1, node0, nullid, 1, stored1,
                                    censored=True)
 
         delta = mdiff.textdiff(b'bar\n' * 30, (b'bar\n' * 30) + b'baz\n')
         deltas = [(b'\xcc' * 20, node1, nullid, b'\x01' * 20, node1, delta, 0)]
 
         with self._maketransactionfn() as tr:
             with self.assertRaises(error.CensoredBaseError):
                 f.addgroup(deltas, lambda x: 0, tr)
 
     def testcensorrevisionbasic(self):
         f = self._makefilefn()
 
         with self._maketransactionfn() as tr:
             node0 = f.add(b'foo\n' * 30, None, tr, 0, nullid, nullid)
             node1 = f.add(b'foo\n' * 31, None, tr, 1, node0, nullid)
             node2 = f.add(b'foo\n' * 32, None, tr, 2, node1, nullid)
 
         with self._maketransactionfn() as tr:
             f.censorrevision(tr, node1)
 
         self.assertEqual(len(f), 3)
         self.assertEqual(list(f.revs()), [0, 1, 2])
 
         self.assertEqual(f.read(node0), b'foo\n' * 30)
         self.assertEqual(f.read(node2), b'foo\n' * 32)
 
         with self.assertRaises(error.CensoredNodeError):
             f.read(node1)
 
     def testgetstrippointnoparents(self):
         # N revisions where none have parents.
         f = self._makefilefn()
 
         with self._maketransactionfn() as tr:
             for rev in range(10):
                 f.add(b'%d' % rev, None, tr, rev, nullid, nullid)
 
         for rev in range(10):
             self.assertEqual(f.getstrippoint(rev), (rev, set()))
 
     def testgetstrippointlinear(self):
         # N revisions in a linear chain.
         f = self._makefilefn()
 
         with self._maketransactionfn() as tr:
             p1 = nullid
 
             for rev in range(10):
                 f.add(b'%d' % rev, None, tr, rev, p1, nullid)
 
         for rev in range(10):
             self.assertEqual(f.getstrippoint(rev), (rev, set()))
 
     def testgetstrippointmultipleheads(self):
         f = self._makefilefn()
 
         with self._maketransactionfn() as tr:
             node0 = f.add(b'0', None, tr, 0, nullid, nullid)
             node1 = f.add(b'1', None, tr, 1, node0, nullid)
             f.add(b'2', None, tr, 2, node1, nullid)
             f.add(b'3', None, tr, 3, node0, nullid)
             f.add(b'4', None, tr, 4, node0, nullid)
 
         for rev in range(5):
             self.assertEqual(f.getstrippoint(rev), (rev, set()))
 
     def testgetstrippointearlierlinkrevs(self):
         f = self._makefilefn()
 
         with self._maketransactionfn() as tr:
             node0 = f.add(b'0', None, tr, 0, nullid, nullid)
             f.add(b'1', None, tr, 10, node0, nullid)
             f.add(b'2', None, tr, 5, node0, nullid)
 
         self.assertEqual(f.getstrippoint(0), (0, set()))
         self.assertEqual(f.getstrippoint(1), (1, set()))
         self.assertEqual(f.getstrippoint(2), (1, set()))
         self.assertEqual(f.getstrippoint(3), (1, set()))
         self.assertEqual(f.getstrippoint(4), (1, set()))
         self.assertEqual(f.getstrippoint(5), (1, set()))
         self.assertEqual(f.getstrippoint(6), (1, {2}))
         self.assertEqual(f.getstrippoint(7), (1, {2}))
         self.assertEqual(f.getstrippoint(8), (1, {2}))
         self.assertEqual(f.getstrippoint(9), (1, {2}))
         self.assertEqual(f.getstrippoint(10), (1, {2}))
         self.assertEqual(f.getstrippoint(11), (3, set()))
 
     def teststripempty(self):
         f = self._makefilefn()
 
         with self._maketransactionfn() as tr:
             f.strip(0, tr)
 
         self.assertEqual(len(f), 0)
 
     def teststripall(self):
         f = self._makefilefn()
 
         with self._maketransactionfn() as tr:
             p1 = nullid
             for rev in range(10):
                 p1 = f.add(b'%d' % rev, None, tr, rev, p1, nullid)
 
         self.assertEqual(len(f), 10)
 
         with self._maketransactionfn() as tr:
             f.strip(0, tr)
 
         self.assertEqual(len(f), 0)
 
     def teststrippartial(self):
         f = self._makefilefn()
 
         with self._maketransactionfn() as tr:
             f.add(b'0', None, tr, 0, nullid, nullid)
             node1 = f.add(b'1', None, tr, 5, nullid, nullid)
             node2 = f.add(b'2', None, tr, 10, nullid, nullid)
 
         self.assertEqual(len(f), 3)
 
         with self._maketransactionfn() as tr:
             f.strip(11, tr)
 
         self.assertEqual(len(f), 3)
 
         with self._maketransactionfn() as tr:
             f.strip(10, tr)
 
         self.assertEqual(len(f), 2)
 
         with self.assertRaises(error.LookupError):
             f.rev(node2)
 
         with self._maketransactionfn() as tr:
             f.strip(6, tr)
 
         self.assertEqual(len(f), 2)
 
         with self._maketransactionfn() as tr:
             f.strip(3, tr)
 
         self.assertEqual(len(f), 1)
 
         with self.assertRaises(error.LookupError):
             f.rev(node1)
 
 def makeifileindextests(makefilefn, maketransactionfn, addrawrevisionfn):
     """Create a unittest.TestCase class suitable for testing file storage.
 
     ``makefilefn`` is a callable which receives the test case as an
     argument and returns an object implementing the ``ifilestorage`` interface.
 
     ``maketransactionfn`` is a callable which receives the test case as an
     argument and returns a transaction object.
 
     ``addrawrevisionfn`` is a callable which receives arguments describing a
     low-level revision to add. This callable allows the insertion of
     potentially bad data into the store in order to facilitate testing.
 
     Returns a type that is a ``unittest.TestCase`` that can be used for
     testing the object implementing the file storage interface. Simply
     assign the returned value to a module-level attribute and a test loader
     should find and run it automatically.
     """
     d = {
         r'_makefilefn': makefilefn,
         r'_maketransactionfn': maketransactionfn,
         r'_addrawrevisionfn': addrawrevisionfn,
     }
     return type(r'ifileindextests', (ifileindextests,), d)
 
 def makeifiledatatests(makefilefn, maketransactionfn, addrawrevisionfn):
     d = {
         r'_makefilefn': makefilefn,
         r'_maketransactionfn': maketransactionfn,
         r'_addrawrevisionfn': addrawrevisionfn,
     }
     return type(r'ifiledatatests', (ifiledatatests,), d)
 
 def makeifilemutationtests(makefilefn, maketransactionfn, addrawrevisionfn):
     d = {
         r'_makefilefn': makefilefn,
         r'_maketransactionfn': maketransactionfn,
         r'_addrawrevisionfn': addrawrevisionfn,
     }
     return type(r'ifilemutationtests', (ifilemutationtests,), d)