This is an archive of the discontinued Mercurial Phabricator instance.

Differential D335

localrepo: use peer interfaces
ClosedPublic

Authored by indygreg on Aug 11 2017, 12:20 AM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG707750e5310b: localrepo: use peer interfaces
Summary

We now have a formal abstract base class for peers. Let's
transition the peer classes in localrepo to it.

As part of the transition, we reorder methods so they are grouped
by interface and match the order they are defined in the interface.
We also had to change self.ui from an instance attribute to a
property to satisfy the @abstractproperty requirement.

As part of this change, we uncover the first "bug" as part of
enforcing interfaces: stream_out() wasn't implemented on localpeer!
This isn't technically a bug since the repo isn't advertising the
stream capability, so clients shouldn't be attempting to call it.
But I don't think there's a good reason why this is the case.
We implement a dummy method to satisfy the interface requriements.
We can make localpeer instances streamable as a future enhancement.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Aug 11 2017, 12:20 AM
durin42 accepted this revision.Aug 11 2017, 2:27 PM
This revision is now accepted and ready to land.Aug 11 2017, 2:27 PM
Closed by commit rHG707750e5310b: localrepo: use peer interfaces (authored by indygreg). · Explain WhyAug 15 2017, 1:51 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/localrepo.py (97 lines)

Diff 760

mercurial/localrepo.py

mergeutil, mergeutil,
namespaces, namespaces,
obsolete, obsolete,
pathutil, pathutil,
peer, peer,
phases, phases,
pushkey, pushkey,
pycompat, pycompat,
repository,
repoview, repoview,
revset, revset,
revsetlang, revsetlang,
scmutil, scmutil,
sparse, sparse,
store, store,
subrepo, subrepo,
tags as tagsmod, tags as tagsmod,
def wrapper(repo, *args, **kwargs): def wrapper(repo, *args, **kwargs):
return orig(repo.unfiltered(), *args, **kwargs) return orig(repo.unfiltered(), *args, **kwargs)
return wrapper return wrapper
moderncaps = {'lookup', 'branchmap', 'pushkey', 'known', 'getbundle', moderncaps = {'lookup', 'branchmap', 'pushkey', 'known', 'getbundle',
'unbundle'} 'unbundle'}
legacycaps = moderncaps.union({'changegroupsubset'}) legacycaps = moderncaps.union({'changegroupsubset'})
class localpeer(peer.peerrepository): class localpeer(repository.peer):
'''peer for a local repo; reflects only the most recent API''' '''peer for a local repo; reflects only the most recent API'''
def __init__(self, repo, caps=None): def __init__(self, repo, caps=None):
super(localpeer, self).__init__()
if caps is None: if caps is None:
caps = moderncaps.copy() caps = moderncaps.copy()
peer.peerrepository.__init__(self)
self._repo = repo.filtered('served') self._repo = repo.filtered('served')
self.ui = repo.ui self._ui = repo.ui
self._caps = repo._restrictcapabilities(caps) self._caps = repo._restrictcapabilities(caps)
def close(self): # Begin of _basepeer interface.
self._repo.close()
def _capabilities(self): @util.propertycache
return self._caps def ui(self):
return self._ui
def url(self):
return self._repo.url()
def local(self): def local(self):
return self._repo return self._repo
def peer(self):
return self
def canpush(self): def canpush(self):
return True return True
def url(self): def close(self):
return self._repo.url() self._repo.close()
def lookup(self, key): # End of _basepeer interface.
return self._repo.lookup(key)
# Begin of _basewirecommands interface.
def branchmap(self): def branchmap(self):
return self._repo.branchmap() return self._repo.branchmap()
def heads(self): def capabilities(self):
return self._repo.heads() return self._caps
def known(self, nodes): def debugwireargs(self, one, two, three=None, four=None, five=None):
return self._repo.known(nodes) """Used to test argument passing over the wire"""
return "%s %s %s %s %s" % (one, two, three, four, five)
def getbundle(self, source, heads=None, common=None, bundlecaps=None, def getbundle(self, source, heads=None, common=None, bundlecaps=None,
**kwargs): **kwargs):
chunks = exchange.getbundlechunks(self._repo, source, heads=heads, chunks = exchange.getbundlechunks(self._repo, source, heads=heads,
common=common, bundlecaps=bundlecaps, common=common, bundlecaps=bundlecaps,
**kwargs) **kwargs)
cb = util.chunkbuffer(chunks) cb = util.chunkbuffer(chunks)
if exchange.bundle2requested(bundlecaps): if exchange.bundle2requested(bundlecaps):
# When requesting a bundle2, getbundle returns a stream to make the # When requesting a bundle2, getbundle returns a stream to make the
# wire level function happier. We need to build a proper object # wire level function happier. We need to build a proper object
# from it in local peer. # from it in local peer.
return bundle2.getunbundler(self.ui, cb) return bundle2.getunbundler(self.ui, cb)
else: else:
return changegroup.getunbundler('01', cb, None) return changegroup.getunbundler('01', cb, None)
# TODO We might want to move the next two calls into legacypeer and add def heads(self):
# unbundle instead. return self._repo.heads()
def known(self, nodes):
return self._repo.known(nodes)
def listkeys(self, namespace):
return self._repo.listkeys(namespace)
def lookup(self, key):
return self._repo.lookup(key)
def pushkey(self, namespace, key, old, new):
return self._repo.pushkey(namespace, key, old, new)
def stream_out(self):
raise error.Abort(_('cannot perform stream clone against local '
'peer'))
def unbundle(self, cg, heads, url): def unbundle(self, cg, heads, url):
"""apply a bundle on a repo """apply a bundle on a repo
This function handles the repo locking itself.""" This function handles the repo locking itself."""
try: try:
try: try:
cg = exchange.readbundle(self.ui, cg, None) cg = exchange.readbundle(self.ui, cg, None)
bundler.addpart(out) bundler.addpart(out)
stream = util.chunkbuffer(bundler.getchunks()) stream = util.chunkbuffer(bundler.getchunks())
b = bundle2.getunbundler(self.ui, stream) b = bundle2.getunbundler(self.ui, stream)
bundle2.processbundle(self._repo, b) bundle2.processbundle(self._repo, b)
raise raise
except error.PushRaced as exc: except error.PushRaced as exc:
raise error.ResponseError(_('push failed:'), str(exc)) raise error.ResponseError(_('push failed:'), str(exc))
def pushkey(self, namespace, key, old, new): # End of _basewirecommands interface.
return self._repo.pushkey(namespace, key, old, new)
def listkeys(self, namespace): # Begin of peer interface.
return self._repo.listkeys(namespace)
def debugwireargs(self, one, two, three=None, four=None, five=None): def iterbatch(self):
'''used to test argument passing over the wire''' return peer.localiterbatcher(self)
return "%s %s %s %s %s" % (one, two, three, four, five)
# End of peer interface.
class locallegacypeer(localpeer): class locallegacypeer(repository.legacypeer, localpeer):
'''peer extension which implements legacy methods too; used for tests with '''peer extension which implements legacy methods too; used for tests with
restricted capabilities''' restricted capabilities'''
def __init__(self, repo): def __init__(self, repo):
localpeer.__init__(self, repo, caps=legacycaps) super(locallegacypeer, self).__init__(repo, caps=legacycaps)
def branches(self, nodes): # Begin of baselegacywirecommands interface.
return self._repo.branches(nodes)
def between(self, pairs): def between(self, pairs):
return self._repo.between(pairs) return self._repo.between(pairs)
def branches(self, nodes):
return self._repo.branches(nodes)
def changegroup(self, basenodes, source): def changegroup(self, basenodes, source):
return changegroup.changegroup(self._repo, basenodes, source) return changegroup.changegroup(self._repo, basenodes, source)
def changegroupsubset(self, bases, heads, source): def changegroupsubset(self, bases, heads, source):
return changegroup.changegroupsubset(self._repo, bases, heads, source) return changegroup.changegroupsubset(self._repo, bases, heads, source)
# End of baselegacywirecommands interface.
# Increment the sub-version when the revlog v2 format changes to lock out old # Increment the sub-version when the revlog v2 format changes to lock out old
# clients. # clients.
REVLOGV2_REQUIREMENT = 'exp-revlogv2.0' REVLOGV2_REQUIREMENT = 'exp-revlogv2.0'
class localrepository(object): class localrepository(object):
supportedformats = { supportedformats = {
'revlogv1', 'revlogv1',