manifest: proxy to revlog instance instead of inheriting
Previously, manifestrevlog inherited revlog.revlog and therefore
exposed all its APIs. This inevitably resulted in consumers calling
low-level revlog APIs.
As part of abstracting storage, we want to formalize the interface
for manifest storage. The revlog API is much too large to define as
the interface.
Like we did for filelog, this commit divorces the manifest class
from revlog so that we can standardize on a smaller API surface.
The way I went about this commit was I broke the inheritance, ran
tests, and added proxies until all tests passed. Like filelog, there
are a handful of attributes that don't belong on the interface.
And like filelog, we'll tease these out in the future.
As part of this, we formalize an interface for manifest storage and
add checks that manifestrevlog conforms to the interface.
Adding proxies will introduce some overhead due to extra attribute
lookups and function calls. On the mozilla-unified repository:
$ hg verify
before: real 627.220 secs (user 525.870+0.000 sys 18.800+0.000)
after: real 628.930 secs (user 532.050+0.000 sys 18.320+0.000)
$ hg serve (for a clone)
before: user 223.580+0.000 sys 14.270+0.000
after: user 227.720+0.000 sys 13.920+0.000
$ hg clone
before: user 506.390+0.000 sys 29.720+0.000
after: user 513.080+0.000 sys 28.280+0.000
There appears to be some overhead here. But it appears to be 1-2%.
I think that is an appropriate price to pay for storage abstraction,
which will eventually let us have much nicer things. If the overhead
is noticed in other operations (whose CPU time isn't likely dwarfed by
fulltext resolution) or if we want to cut down on the overhead, we
could dynamically build up a type whose methods are effectively
aliased to a revlog instance's. I'm inclined to punt on that problem
for now. We may have to do it for the changelog. At which point it
could be implemented in a generic way and ported to filelog and
manifestrevlog easily enough I would think.
.. api:: manifest.manifestrevlog no longer inherits from revlog
The manifestrevlog class now wraps a revlog instance instead of
inheriting from revlog. Various attributes and methods on instances
are no longer available.
Differential Revision: https://phab.mercurial-scm.org/D4386
# Test that certain objects conform to well-defined interfaces.
from __future__ import absolute_import, print_function
from mercurial import encoding
encoding.environ[b'HGREALINTERFACES'] = b'1'
import os
import subprocess
import sys
# Only run if tests are run in a repo
if subprocess.call(['python', '%s/hghave' % os.environ['TESTDIR'],
'test-repo']):
sys.exit(80)
from mercurial.thirdparty.zope import (
interface as zi,
)
from mercurial.thirdparty.zope.interface import (
verify as ziverify,
)
from mercurial import (
changegroup,
bundlerepo,
filelog,
httppeer,
localrepo,
manifest,
pycompat,
repository,
revlog,
sshpeer,
statichttprepo,
ui as uimod,
unionrepo,
vfs as vfsmod,
wireprotoserver,
wireprototypes,
wireprotov1peer,
wireprotov2server,
)
rootdir = pycompat.fsencode(
os.path.normpath(os.path.join(os.path.dirname(__file__), '..')))
def checkzobject(o, allowextra=False):
"""Verify an object with a zope interface."""
ifaces = zi.providedBy(o)
if not ifaces:
print('%r does not provide any zope interfaces' % o)
return
# Run zope.interface's built-in verification routine. This verifies that
# everything that is supposed to be present is present.
for iface in ifaces:
ziverify.verifyObject(iface, o)
if allowextra:
return
# Now verify that the object provides no extra public attributes that
# aren't declared as part of interfaces.
allowed = set()
for iface in ifaces:
allowed |= set(iface.names(all=True))
public = {a for a in dir(o) if not a.startswith('_')}
for attr in sorted(public - allowed):
print('public attribute not declared in interfaces: %s.%s' % (
o.__class__.__name__, attr))
# Facilitates testing localpeer.
class dummyrepo(object):
def __init__(self):
self.ui = uimod.ui()
def filtered(self, name):
pass
def _restrictcapabilities(self, caps):
pass
class dummyopener(object):
handlers = []
# Facilitates testing sshpeer without requiring a server.
class badpeer(httppeer.httppeer):
def __init__(self):
super(badpeer, self).__init__(None, None, None, dummyopener(), None,
None)
self.badattribute = True
def badmethod(self):
pass
class dummypipe(object):
def close(self):
pass
def main():
ui = uimod.ui()
# Needed so we can open a local repo with obsstore without a warning.
ui.setconfig('experimental', 'evolution.createmarkers', True)
checkzobject(badpeer())
ziverify.verifyClass(repository.ipeerbase, httppeer.httppeer)
checkzobject(httppeer.httppeer(None, None, None, dummyopener(), None, None))
ziverify.verifyClass(repository.ipeerconnection,
httppeer.httpv2peer)
ziverify.verifyClass(repository.ipeercapabilities,
httppeer.httpv2peer)
checkzobject(httppeer.httpv2peer(None, b'', b'', None, None, None))
ziverify.verifyClass(repository.ipeerbase,
localrepo.localpeer)
checkzobject(localrepo.localpeer(dummyrepo()))
ziverify.verifyClass(repository.ipeercommandexecutor,
localrepo.localcommandexecutor)
checkzobject(localrepo.localcommandexecutor(None))
ziverify.verifyClass(repository.ipeercommandexecutor,
wireprotov1peer.peerexecutor)
checkzobject(wireprotov1peer.peerexecutor(None))
ziverify.verifyClass(repository.ipeerbase, sshpeer.sshv1peer)
checkzobject(sshpeer.sshv1peer(ui, b'ssh://localhost/foo', b'', dummypipe(),
dummypipe(), None, None))
ziverify.verifyClass(repository.ipeerbase, sshpeer.sshv2peer)
checkzobject(sshpeer.sshv2peer(ui, b'ssh://localhost/foo', b'', dummypipe(),
dummypipe(), None, None))
ziverify.verifyClass(repository.ipeerbase, bundlerepo.bundlepeer)
checkzobject(bundlerepo.bundlepeer(dummyrepo()))
ziverify.verifyClass(repository.ipeerbase, statichttprepo.statichttppeer)
checkzobject(statichttprepo.statichttppeer(dummyrepo()))
ziverify.verifyClass(repository.ipeerbase, unionrepo.unionpeer)
checkzobject(unionrepo.unionpeer(dummyrepo()))
ziverify.verifyClass(repository.completelocalrepository,
localrepo.localrepository)
repo = localrepo.localrepository(ui, rootdir)
checkzobject(repo)
ziverify.verifyClass(wireprototypes.baseprotocolhandler,
wireprotoserver.sshv1protocolhandler)
ziverify.verifyClass(wireprototypes.baseprotocolhandler,
wireprotoserver.sshv2protocolhandler)
ziverify.verifyClass(wireprototypes.baseprotocolhandler,
wireprotoserver.httpv1protocolhandler)
ziverify.verifyClass(wireprototypes.baseprotocolhandler,
wireprotov2server.httpv2protocolhandler)
sshv1 = wireprotoserver.sshv1protocolhandler(None, None, None)
checkzobject(sshv1)
sshv2 = wireprotoserver.sshv2protocolhandler(None, None, None)
checkzobject(sshv2)
httpv1 = wireprotoserver.httpv1protocolhandler(None, None, None)
checkzobject(httpv1)
httpv2 = wireprotov2server.httpv2protocolhandler(None, None)
checkzobject(httpv2)
ziverify.verifyClass(repository.ifilestorage, filelog.filelog)
ziverify.verifyClass(repository.imanifestdict, manifest.manifestdict)
ziverify.verifyClass(repository.imanifestrevisionstored,
manifest.manifestctx)
ziverify.verifyClass(repository.imanifestrevisionwritable,
manifest.memmanifestctx)
ziverify.verifyClass(repository.imanifestrevisionstored,
manifest.treemanifestctx)
ziverify.verifyClass(repository.imanifestrevisionwritable,
manifest.memtreemanifestctx)
ziverify.verifyClass(repository.imanifestlog, manifest.manifestlog)
ziverify.verifyClass(repository.imanifeststorage, manifest.manifestrevlog)
vfs = vfsmod.vfs(b'.')
fl = filelog.filelog(vfs, b'dummy.i')
checkzobject(fl, allowextra=True)
# Conforms to imanifestlog.
ml = manifest.manifestlog(vfs, repo)
checkzobject(ml)
checkzobject(repo.manifestlog)
# Conforms to imanifestrevision.
mctx = ml[repo[0].manifestnode()]
checkzobject(mctx)
# Conforms to imanifestrevisionwritable.
checkzobject(mctx.new())
checkzobject(mctx.copy())
# Conforms to imanifestdict.
checkzobject(mctx.read())
mrl = manifest.manifestrevlog(vfs)
checkzobject(mrl)
ziverify.verifyClass(repository.irevisiondelta,
revlog.revlogrevisiondelta)
ziverify.verifyClass(repository.irevisiondeltarequest,
changegroup.revisiondeltarequest)
rd = revlog.revlogrevisiondelta(
node=b'',
p1node=b'',
p2node=b'',
basenode=b'',
linknode=b'',
flags=b'',
baserevisionsize=None,
revision=b'',
delta=None)
checkzobject(rd)
rdr = changegroup.revisiondeltarequest(
node=b'',
linknode=b'',
p1node=b'',
p2node=b'',
basenode=b'')
checkzobject(rdr)
main()