This is an archive of the discontinued Mercurial Phabricator instance.

Differential D3068

repository: port peer interfaces to zope.interface
ClosedPublic

Authored by indygreg on Apr 3 2018, 10:00 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG39f7d4ee8bcd: repository: port peer interfaces to zope.interface
Summary

zope.interface is superior. Let's switch to it.

Unlike abc, which defines interfaces through a base class,
zope.interface uses different types for interfaces and for
implementations. So, we had to invent some new types to hold the
interfaces in order to separate the interface from its default
implementation.

The names here could probably be better. I've been wanting to
overhaul the peer interface for a while. And wire protocol version
2 will force that work. So anticipate a refactoring of these
interfaces in later commits.

With this commit, we no longer test abc interfaces in
test-check-interfaces.py, so code for that has been removed.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Apr 3 2018, 10:00 PM
Closed by commit rHG39f7d4ee8bcd: repository: port peer interfaces to zope.interface (authored by indygreg). · Explain WhyApr 4 2018, 9:39 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 7611

mercurial/httppeer.py

start = util.timer() start = util.timer()
ret = self._urlopener.open(req) ret = self._urlopener.open(req)
if self._ui.configbool('devel', 'debug.peer-request'): if self._ui.configbool('devel', 'debug.peer-request'):
dbg(line % ' finished in %.4f seconds (%s)' dbg(line % ' finished in %.4f seconds (%s)'
% (util.timer() - start, ret.code)) % (util.timer() - start, ret.code))
return ret return ret
# Begin of _basepeer interface. # Begin of ipeerconnection interface.
@util.propertycache @util.propertycache
def ui(self): def ui(self):
return self._ui return self._ui
def url(self): def url(self):
return self._path return self._path
def local(self): def local(self):
return None return None
def peer(self): def peer(self):
return self return self
def canpush(self): def canpush(self):
return True return True
def close(self): def close(self):
pass pass
# End of _basepeer interface. # End of ipeerconnection interface.
# Begin of _basewirepeer interface. # Begin of ipeercommands interface.
def capabilities(self): def capabilities(self):
# self._fetchcaps() should have been called as part of peer # self._fetchcaps() should have been called as part of peer
# handshake. So self._caps should always be set. # handshake. So self._caps should always be set.
assert self._caps is not None assert self._caps is not None
return self._caps return self._caps
# End of _basewirepeer interface. # End of ipeercommands interface.
# look up capabilities only when needed # look up capabilities only when needed
def _fetchcaps(self): def _fetchcaps(self):
self._caps = set(self._call('capabilities').split()) self._caps = set(self._call('capabilities').split())
def _callstream(self, cmd, _compressible=False, **args): def _callstream(self, cmd, _compressible=False, **args):
args = pycompat.byteskwargs(args) args = pycompat.byteskwargs(args)

mercurial/repository.py

# repository.py - Interfaces and base classes for repositories and peers. # repository.py - Interfaces and base classes for repositories and peers.
# #
# Copyright 2017 Gregory Szorc <gregory.szorc@gmail.com> # Copyright 2017 Gregory Szorc <gregory.szorc@gmail.com>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import abc
from .i18n import _ from .i18n import _
from .thirdparty.zope import ( from .thirdparty.zope import (
interface as zi, interface as zi,
) )
from . import ( from . import (
error, error,
) )
class _basepeer(object): class ipeerconnection(zi.Interface):
"""Represents a "connection" to a repository. """Represents a "connection" to a repository.
This is the base interface for representing 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. It holds basic properties and methods applicable to all peer types.
This is not a complete interface definition and should not be used This is not a complete interface definition and should not be used
outside of this module. outside of this module.
""" """
__metaclass__ = abc.ABCMeta ui = zi.Attribute("""ui.ui instance""")
@abc.abstractproperty
def ui(self):
"""ui.ui instance."""
@abc.abstractmethod def url():
def url(self):
"""Returns a URL string representing this peer. """Returns a URL string representing this peer.
Currently, implementations expose the raw URL used to construct the Currently, implementations expose the raw URL used to construct the
instance. It may contain credentials as part of the URL. 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 expectations of the value aren't well-defined and this could lead to
data leakage. data leakage.
TODO audit/clean consumers and more clearly define the contents of this TODO audit/clean consumers and more clearly define the contents of this
value. value.
""" """
@abc.abstractmethod def local():
def local(self):
"""Returns a local repository instance. """Returns a local repository instance.
If the peer represents a local repository, returns an object that If the peer represents a local repository, returns an object that
can be used to interface with it. Otherwise returns ``None``. can be used to interface with it. Otherwise returns ``None``.
""" """
@abc.abstractmethod def peer():
def peer(self):
"""Returns an object conforming to this interface. """Returns an object conforming to this interface.
Most implementations will ``return self``. Most implementations will ``return self``.
""" """
@abc.abstractmethod def canpush():
def canpush(self):
"""Returns a boolean indicating if this peer can be pushed to.""" """Returns a boolean indicating if this peer can be pushed to."""
@abc.abstractmethod def close():
def close(self):
"""Close the connection to this peer. """Close the connection to this peer.
This is called when the peer will no longer be used. Resources This is called when the peer will no longer be used. Resources
associated with the peer should be cleaned up. associated with the peer should be cleaned up.
""" """
class _basewirecommands(object): class ipeercommands(zi.Interface):
"""Client-side interface for communicating over the wire protocol. """Client-side interface for communicating over the wire protocol.
This interface is used as a gateway to the Mercurial wire protocol. This interface is used as a gateway to the Mercurial wire protocol.
methods commonly call wire protocol commands of the same name. methods commonly call wire protocol commands of the same name.
""" """
__metaclass__ = abc.ABCMeta
@abc.abstractmethod def branchmap():
def branchmap(self):
"""Obtain heads in named branches. """Obtain heads in named branches.
Returns a dict mapping branch name to an iterable of nodes that are Returns a dict mapping branch name to an iterable of nodes that are
heads on that branch. heads on that branch.
""" """
@abc.abstractmethod def capabilities():
def capabilities(self):
"""Obtain capabilities of the peer. """Obtain capabilities of the peer.
Returns a set of string capabilities. Returns a set of string capabilities.
""" """
@abc.abstractmethod def debugwireargs(one, two, three=None, four=None, five=None):
def debugwireargs(self, one, two, three=None, four=None, five=None):
"""Used to facilitate debugging of arguments passed over the wire.""" """Used to facilitate debugging of arguments passed over the wire."""
@abc.abstractmethod def getbundle(source, **kwargs):
def getbundle(self, source, **kwargs):
"""Obtain remote repository data as a bundle. """Obtain remote repository data as a bundle.
This command is how the bulk of repository data is transferred from This command is how the bulk of repository data is transferred from
the peer to the local repository the peer to the local repository
Returns a generator of bundle data. Returns a generator of bundle data.
""" """
@abc.abstractmethod def heads():
def heads(self):
"""Determine all known head revisions in the peer. """Determine all known head revisions in the peer.
Returns an iterable of binary nodes. Returns an iterable of binary nodes.
""" """
@abc.abstractmethod def known(nodes):
def known(self, nodes):
"""Determine whether multiple nodes are known. """Determine whether multiple nodes are known.
Accepts an iterable of nodes whose presence to check for. Accepts an iterable of nodes whose presence to check for.
Returns an iterable of booleans indicating of the corresponding node Returns an iterable of booleans indicating of the corresponding node
at that index is known to the peer. at that index is known to the peer.
""" """
@abc.abstractmethod def listkeys(namespace):
def listkeys(self, namespace):
"""Obtain all keys in a pushkey namespace. """Obtain all keys in a pushkey namespace.
Returns an iterable of key names. Returns an iterable of key names.
""" """
@abc.abstractmethod def lookup(key):
def lookup(self, key):
"""Resolve a value to a known revision. """Resolve a value to a known revision.
Returns a binary node of the resolved revision on success. Returns a binary node of the resolved revision on success.
""" """
@abc.abstractmethod def pushkey(namespace, key, old, new):
def pushkey(self, namespace, key, old, new):
"""Set a value using the ``pushkey`` protocol. """Set a value using the ``pushkey`` protocol.
Arguments correspond to the pushkey namespace and key to operate on and Arguments correspond to the pushkey namespace and key to operate on and
the old and new values for that key. the old and new values for that key.
Returns a string with the peer result. The value inside varies by the Returns a string with the peer result. The value inside varies by the
namespace. namespace.
""" """
@abc.abstractmethod def stream_out():
def stream_out(self):
"""Obtain streaming clone data. """Obtain streaming clone data.
Successful result should be a generator of data chunks. Successful result should be a generator of data chunks.
""" """
@abc.abstractmethod def unbundle(bundle, heads, url):
def unbundle(self, bundle, heads, url):
"""Transfer repository data to the peer. """Transfer repository data to the peer.
This is how the bulk of data during a push is transferred. This is how the bulk of data during a push is transferred.
Returns the integer number of heads added to the peer. Returns the integer number of heads added to the peer.
""" """
class _baselegacywirecommands(object): class ipeerlegacycommands(zi.Interface):
"""Interface for implementing support for legacy wire protocol commands. """Interface for implementing support for legacy wire protocol commands.
Wire protocol commands transition to legacy status when they are no longer Wire protocol commands transition to legacy status when they are no longer
used by modern clients. To facilitate identifying which commands are used by modern clients. To facilitate identifying which commands are
legacy, the interfaces are split. legacy, the interfaces are split.
""" """
__metaclass__ = abc.ABCMeta
@abc.abstractmethod def between(pairs):
def between(self, pairs):
"""Obtain nodes between pairs of nodes. """Obtain nodes between pairs of nodes.
``pairs`` is an iterable of node pairs. ``pairs`` is an iterable of node pairs.
Returns an iterable of iterables of nodes corresponding to each Returns an iterable of iterables of nodes corresponding to each
requested pair. requested pair.
""" """
@abc.abstractmethod def branches(nodes):
def branches(self, nodes):
"""Obtain ancestor changesets of specific nodes back to a branch point. """Obtain ancestor changesets of specific nodes back to a branch point.
For each requested node, the peer finds the first ancestor node that is For each requested node, the peer finds the first ancestor node that is
a DAG root or is a merge. a DAG root or is a merge.
Returns an iterable of iterables with the resolved values for each node. Returns an iterable of iterables with the resolved values for each node.
""" """
@abc.abstractmethod def changegroup(nodes, kind):
def changegroup(self, nodes, kind):
"""Obtain a changegroup with data for descendants of specified nodes.""" """Obtain a changegroup with data for descendants of specified nodes."""
@abc.abstractmethod def changegroupsubset(bases, heads, kind):
def changegroupsubset(self, bases, heads, kind):
pass pass
class peer(_basepeer, _basewirecommands): class ipeerbase(ipeerconnection, ipeercommands):
"""Unified interface and base class for peer repositories. """Unified interface for peer repositories.
All peer instances must inherit from this class and conform to its All peer instances must conform to this interface.
interface.
""" """
def iterbatch():
@abc.abstractmethod
def iterbatch(self):
"""Obtain an object to be used for multiple method calls. """Obtain an object to be used for multiple method calls.
Various operations call several methods on peer instances. If each Various operations call several methods on peer instances. If each
method call were performed immediately and serially, this would method call were performed immediately and serially, this would
require round trips to remote peers and/or would slow down execution. require round trips to remote peers and/or would slow down execution.
Some peers have the ability to "batch" method calls to avoid costly Some peers have the ability to "batch" method calls to avoid costly
round trips or to facilitate concurrent execution. round trips or to facilitate concurrent execution.
This method returns an object that can be used to indicate intent to This method returns an object that can be used to indicate intent to
perform batched method calls. perform batched method calls.
The returned object is a proxy of this peer. It intercepts calls to The returned object is a proxy of this peer. It intercepts calls to
batchable methods and queues them instead of performing them batchable methods and queues them instead of performing them
immediately. This proxy object has a ``submit`` method that will immediately. This proxy object has a ``submit`` method that will
perform all queued batchable method calls. A ``results()`` method perform all queued batchable method calls. A ``results()`` method
exposes the results of queued/batched method calls. It is a generator exposes the results of queued/batched method calls. It is a generator
of results in the order they were called. of results in the order they were called.
Not all peers or wire protocol implementations may actually batch method Not all peers or wire protocol implementations may actually batch method
calls. However, they must all support this API. calls. However, they must all support this API.
""" """
def capable(self, name): def capable(name):
"""Determine support for a named capability. """Determine support for a named capability.
Returns ``False`` if capability not supported. Returns ``False`` if capability not supported.
Returns ``True`` if boolean capability is supported. Returns a string Returns ``True`` if boolean capability is supported. Returns a string
if capability support is non-boolean. if capability support is non-boolean.
""" """
def requirecap(name, purpose):
"""Require a capability to be present.
Raises a ``CapabilityError`` if the capability isn't present.
"""
class ipeerbaselegacycommands(ipeerbase, ipeerlegacycommands):
"""Unified peer interface that supports legacy commands."""
@zi.implementer(ipeerbase)
class peer(object):
"""Base class for peer repositories."""
def capable(self, name):
caps = self.capabilities() caps = self.capabilities()
if name in caps: if name in caps:
return True return True
name = '%s=' % name name = '%s=' % name
for cap in caps: for cap in caps:
if cap.startswith(name): if cap.startswith(name):
return cap[len(name):] return cap[len(name):]
return False return False
def requirecap(self, name, purpose): def requirecap(self, name, purpose):
"""Require a capability to be present.
Raises a ``CapabilityError`` if the capability isn't present.
"""
if self.capable(name): if self.capable(name):
return return
raise error.CapabilityError( raise error.CapabilityError(
_('cannot %s; remote repository does not support the %r ' _('cannot %s; remote repository does not support the %r '
'capability') % (purpose, name)) 'capability') % (purpose, name))
class legacypeer(peer, _baselegacywirecommands): @zi.implementer(ipeerbaselegacycommands)
class legacypeer(peer):
"""peer but with support for legacy wire protocol commands.""" """peer but with support for legacy wire protocol commands."""
class completelocalrepository(zi.Interface): class completelocalrepository(zi.Interface):
"""Monolithic interface for local repositories. """Monolithic interface for local repositories.
This currently captures the reality of things - not how things should be. This currently captures the reality of things - not how things should be.
""" """

mercurial/sshpeer.py

self._autoreadstderr = autoreadstderr self._autoreadstderr = autoreadstderr
# Commands that have a "framed" response where the first line of the # Commands that have a "framed" response where the first line of the
# response contains the length of that response. # response contains the length of that response.
_FRAMED_COMMANDS = { _FRAMED_COMMANDS = {
'batch', 'batch',
} }
# Begin of _basepeer interface. # Begin of ipeerconnection interface.
@util.propertycache @util.propertycache
def ui(self): def ui(self):
return self._ui return self._ui
def url(self): def url(self):
return self._url return self._url
def local(self): def local(self):
return None return None
def peer(self): def peer(self):
return self return self
def canpush(self): def canpush(self):
return True return True
def close(self): def close(self):
pass pass
# End of _basepeer interface. # End of ipeerconnection interface.
# Begin of _basewirecommands interface. # Begin of ipeercommands interface.
def capabilities(self): def capabilities(self):
return self._caps return self._caps
# End of _basewirecommands interface. # End of ipeercommands interface.
def _readerr(self): def _readerr(self):
_forwardoutput(self.ui, self._pipee) _forwardoutput(self.ui, self._pipee)
def _abort(self, exception): def _abort(self, exception):
self._cleanup() self._cleanup()
raise exception raise exception

mercurial/wireproto.py

class wirepeer(repository.legacypeer): class wirepeer(repository.legacypeer):
"""Client-side interface for communicating with a peer repository. """Client-side interface for communicating with a peer repository.
Methods commonly call wire protocol commands of the same name. Methods commonly call wire protocol commands of the same name.
See also httppeer.py and sshpeer.py for protocol-specific See also httppeer.py and sshpeer.py for protocol-specific
implementations of this interface. implementations of this interface.
""" """
# Begin of basewirepeer interface. # Begin of ipeercommands interface.
def iterbatch(self): def iterbatch(self):
return remoteiterbatcher(self) return remoteiterbatcher(self)
@batchable @batchable
def lookup(self, key): def lookup(self, key):
self.requirecap('lookup', _('look up remote revision')) self.requirecap('lookup', _('look up remote revision'))
f = future() f = future()
for l in output.splitlines(True): for l in output.splitlines(True):
self.ui.status(_('remote: '), l) self.ui.status(_('remote: '), l)
else: else:
# bundle2 push. Send a stream, fetch a stream. # bundle2 push. Send a stream, fetch a stream.
stream = self._calltwowaystream('unbundle', cg, heads=heads) stream = self._calltwowaystream('unbundle', cg, heads=heads)
ret = bundle2.getunbundler(self.ui, stream) ret = bundle2.getunbundler(self.ui, stream)
return ret return ret
# End of basewirepeer interface. # End of ipeercommands interface.
# Begin of baselegacywirepeer interface. # Begin of ipeerlegacycommands interface.
def branches(self, nodes): def branches(self, nodes):
n = encodelist(nodes) n = encodelist(nodes)
d = self._call("branches", nodes=n) d = self._call("branches", nodes=n)
try: try:
br = [tuple(decodelist(b)) for b in d.splitlines()] br = [tuple(decodelist(b)) for b in d.splitlines()]
return br return br
except ValueError: except ValueError:
def changegroupsubset(self, bases, heads, kind): def changegroupsubset(self, bases, heads, kind):
self.requirecap('changegroupsubset', _('look up remote changes')) self.requirecap('changegroupsubset', _('look up remote changes'))
bases = encodelist(bases) bases = encodelist(bases)
heads = encodelist(heads) heads = encodelist(heads)
f = self._callcompressable("changegroupsubset", f = self._callcompressable("changegroupsubset",
bases=bases, heads=heads) bases=bases, heads=heads)
return changegroupmod.cg1unpacker(f, 'UN') return changegroupmod.cg1unpacker(f, 'UN')
# End of baselegacywirepeer interface. # End of ipeerlegacycommands interface.
def _submitbatch(self, req): def _submitbatch(self, req):
"""run batch request <req> on the server """run batch request <req> on the server
Returns an iterator of the raw responses from the server. Returns an iterator of the raw responses from the server.
""" """
ui = self.ui ui = self.ui
if ui.debugflag and ui.configbool('devel', 'debug.peer-request'): if ui.debugflag and ui.configbool('devel', 'debug.peer-request'):

tests/test-check-interfaces.py

ui as uimod, ui as uimod,
unionrepo, unionrepo,
wireprotoserver, wireprotoserver,
wireprototypes, wireprototypes,
) )
rootdir = os.path.normpath(os.path.join(os.path.dirname(__file__), '..')) rootdir = os.path.normpath(os.path.join(os.path.dirname(__file__), '..'))
def checkobject(o):
"""Verify a constructed object conforms to interface rules.
An object must have __abstractmethods__ defined.
All "public" attributes of the object (attributes not prefixed with
an underscore) must be in __abstractmethods__ or appear on a base class
with __abstractmethods__.
"""
name = o.__class__.__name__
allowed = set()
for cls in o.__class__.__mro__:
if not getattr(cls, '__abstractmethods__', set()):
continue
allowed |= cls.__abstractmethods__
allowed |= {a for a in dir(cls) if not a.startswith('_')}
if not allowed:
print('%s does not have abstract methods' % name)
return
public = {a for a in dir(o) if not a.startswith('_')}
for attr in sorted(public - allowed):
print('public attributes not in abstract interface: %s.%s' % (
name, attr))
def checkzobject(o): def checkzobject(o):
"""Verify an object with a zope interface.""" """Verify an object with a zope interface."""
ifaces = zi.providedBy(o) ifaces = zi.providedBy(o)
if not ifaces: if not ifaces:
print('%r does not provide any zope interfaces' % o) print('%r does not provide any zope interfaces' % o)
return return
# Run zope.interface's built-in verification routine. This verifies that # Run zope.interface's built-in verification routine. This verifies that
def close(self): def close(self):
pass pass
def main(): def main():
ui = uimod.ui() ui = uimod.ui()
# Needed so we can open a local repo with obsstore without a warning. # Needed so we can open a local repo with obsstore without a warning.
ui.setconfig('experimental', 'evolution.createmarkers', True) ui.setconfig('experimental', 'evolution.createmarkers', True)
checkobject(badpeer()) checkzobject(badpeer())
checkobject(httppeer.httppeer(None, None, None, dummyopener()))
checkobject(localrepo.localpeer(dummyrepo())) ziverify.verifyClass(repository.ipeerbaselegacycommands,
checkobject(sshpeer.sshv1peer(ui, 'ssh://localhost/foo', None, dummypipe(), httppeer.httppeer)
checkzobject(httppeer.httppeer(None, None, None, dummyopener()))
ziverify.verifyClass(repository.ipeerbase,
localrepo.localpeer)
checkzobject(localrepo.localpeer(dummyrepo()))
ziverify.verifyClass(repository.ipeerbaselegacycommands,
sshpeer.sshv1peer)
checkzobject(sshpeer.sshv1peer(ui, 'ssh://localhost/foo', None, dummypipe(),
dummypipe(), None, None)) dummypipe(), None, None))
checkobject(sshpeer.sshv2peer(ui, 'ssh://localhost/foo', None, dummypipe(),
ziverify.verifyClass(repository.ipeerbaselegacycommands,
sshpeer.sshv2peer)
checkzobject(sshpeer.sshv2peer(ui, 'ssh://localhost/foo', None, dummypipe(),
dummypipe(), None, None)) dummypipe(), None, None))
checkobject(bundlerepo.bundlepeer(dummyrepo()))
checkobject(statichttprepo.statichttppeer(dummyrepo())) ziverify.verifyClass(repository.ipeerbase, bundlerepo.bundlepeer)
checkobject(unionrepo.unionpeer(dummyrepo())) 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, ziverify.verifyClass(repository.completelocalrepository,
localrepo.localrepository) localrepo.localrepository)
repo = localrepo.localrepository(ui, rootdir) repo = localrepo.localrepository(ui, rootdir)
checkzobject(repo) checkzobject(repo)
ziverify.verifyClass(wireprototypes.baseprotocolhandler, ziverify.verifyClass(wireprototypes.baseprotocolhandler,
wireprotoserver.sshv1protocolhandler) wireprotoserver.sshv1protocolhandler)

tests/test-check-interfaces.py.out

public attributes not in abstract interface: badpeer.badattribute public attribute not declared in interfaces: badpeer.badattribute
public attributes not in abstract interface: badpeer.badmethod public attribute not declared in interfaces: badpeer.badmethod