mercurial-scm/hg: comparison mercurial/repository.py

equal deleted inserted replaced

-:36d17f37db91
+:39f7d4ee8bcd
 #
 # 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 abc
 from .i18n import _
 from .thirdparty.zope import (
 interface as zi,
 )
 from . import (
 error,
 )
-class _basepeer(object):
+class ipeerconnection(zi.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.
 """
-__metaclass__ = abc.ABCMeta
+ui = zi.Attribute("""ui.ui instance""")
-@abc.abstractproperty
+def url():
-def ui(self):
-"""ui.ui instance."""
-@abc.abstractmethod
-def url(self):
 """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
 TODO audit/clean consumers and more clearly define the contents of this
 value.
 """
-@abc.abstractmethod
+def local():
-def local(self):
 """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``.
 """
-@abc.abstractmethod
+def peer():
-def peer(self):
 """Returns an object conforming to this interface.
 Most implementations will ``return self``.
 """
-@abc.abstractmethod
+def canpush():
-def canpush(self):
 """Returns a boolean indicating if this peer can be pushed to."""
-@abc.abstractmethod
+def close():
-def close(self):
 """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 _basewirecommands(object):
+class ipeercommands(zi.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.
 """
-__metaclass__ = abc.ABCMeta
+def branchmap():
-@abc.abstractmethod
-def branchmap(self):
 """Obtain heads in named branches.
 Returns a dict mapping branch name to an iterable of nodes that are
 heads on that branch.
 """
-@abc.abstractmethod
+def capabilities():
-def capabilities(self):
 """Obtain capabilities of the peer.
 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."""
-@abc.abstractmethod
+def getbundle(source, **kwargs):
-def getbundle(self, 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.
 """
-@abc.abstractmethod
+def heads():
-def heads(self):
 """Determine all known head revisions in the peer.
 Returns an iterable of binary nodes.
 """
-@abc.abstractmethod
+def known(nodes):
-def known(self, 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.
 """
-@abc.abstractmethod
+def listkeys(namespace):
-def listkeys(self, namespace):
 """Obtain all keys in a pushkey namespace.
 Returns an iterable of key names.
 """
-@abc.abstractmethod
+def lookup(key):
-def lookup(self, key):
 """Resolve a value to a known revision.
 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.
 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.
 """
-@abc.abstractmethod
+def stream_out():
-def stream_out(self):
 """Obtain streaming clone data.
 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.
 This is how the bulk of data during a push is transferred.
 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.
 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.
 """
-__metaclass__ = abc.ABCMeta
+def between(pairs):
-@abc.abstractmethod
-def between(self, 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.
 """
-@abc.abstractmethod
+def branches(nodes):
-def branches(self, 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.
 """
-@abc.abstractmethod
+def changegroup(nodes, kind):
-def changegroup(self, nodes, kind):
 """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 ipeerbase(ipeerconnection, ipeercommands):
-class peer(_basepeer, _basewirecommands):
+"""Unified interface for peer repositories.
-"""Unified interface and base class for peer repositories.
+All peer instances must conform to this interface.
-All peer instances must inherit from this class and conform to its
-interface.
 """
+def iterbatch():
-@abc.abstractmethod
-def iterbatch(self):
 """Obtain an object to be used for multiple method calls.
 Various operations call several methods on peer instances. If each
 method call were performed immediately and serially, this would
 require round trips to remote peers and/or would slow down execution.
 Not all peers or wire protocol implementations may actually batch method
 calls. However, they must all support this API.
 """
-def capable(self, name):
+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.
 """
+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()
 if name in caps:
 return True
 name = '%s=' % name
 return cap[len(name):]
 return False
 def requirecap(self, name, purpose):
-"""Require a capability to be present.
-Raises a ``CapabilityError`` if the capability isn't present.
-"""
 if self.capable(name):
 return
 raise error.CapabilityError(
 _('cannot %s; remote repository does not support the %r '
 'capability') % (purpose, name))
-class legacypeer(peer, _baselegacywirecommands):
+@zi.implementer(ipeerbaselegacycommands)
+class legacypeer(peer):
 """peer but with support for legacy wire protocol commands."""
 class completelocalrepository(zi.Interface):
 """Monolithic interface for local repositories.

changeset 37320	39f7d4ee8bcd
parent 37316	836867586b83
child 37351	fdd22bf6398f