This is an archive of the discontinued Mercurial Phabricator instance.

Differential D3273

wireproto: convert legacy commands to command executor
ClosedPublic

Authored by indygreg on Apr 11 2018, 8:12 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHGcc8c06835097: wireproto: convert legacy commands to command executor
Summary

Calls to the legacy commands "changegroup" and "changegroupsubset" have
been ported to the new command executor interface.

Because we always pass arguments by name and not position, some
inconsistent names throughout the code base have been unified.

As part of this change, we no longer had any remaining callers
of the legacy command methods {between, branches, changegroup,
changegroupsubset}. So, these interfaces/methods have been dropped
from peer interfaces. We still have an interface declaring these
methods. But that interface is implemented on the concrete peer
types and isn't part of the generic peer interface. (The
implementations of the command executor continue to call these
methods.)

The ultimate goal is to remove the per-command methods from the
generic peer interface: the only interface-conforming way to
call a command will be with the new executor API. At some point,
we may want to move the methods outside of the peer classes and
change the executor implementations to not call methods directly
on a peer instance.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Apr 11 2018, 8:12 PM
indygreg updated this revision to Diff 8126.Apr 13 2018, 3:14 PM
durin42 accepted this revision.Apr 13 2018, 5:48 PM
This revision is now accepted and ready to land.Apr 13 2018, 5:48 PM
Closed by commit rHGcc8c06835097: wireproto: convert legacy commands to command executor (authored by indygreg). · Explain WhyApr 13 2018, 6:09 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 8040

mercurial/bundlerepo.py

b2 = other.getbundle('incoming', **kwargs) b2 = other.getbundle('incoming', **kwargs)
fname = bundle = changegroup.writechunks(ui, b2._forwardchunks(), fname = bundle = changegroup.writechunks(ui, b2._forwardchunks(),
bundlename) bundlename)
else: else:
if other.capable('getbundle'): if other.capable('getbundle'):
cg = other.getbundle('incoming', common=common, heads=rheads) cg = other.getbundle('incoming', common=common, heads=rheads)
elif onlyheads is None and not other.capable('changegroupsubset'): elif onlyheads is None and not other.capable('changegroupsubset'):
# compat with older servers when pulling all remote heads # compat with older servers when pulling all remote heads
cg = other.changegroup(incoming, "incoming")
with other.commandexecutor() as e:
fcg = e.callcommand('changegroup', {
'nodes': incoming,
'source': 'incoming',
})
cg = fcg.result()
rheads = None rheads = None
else: else:
cg = other.changegroupsubset(incoming, rheads, 'incoming') with other.commandexecutor() as e:
fcg = e.callcommand('changegroupsubset', {
'bases': incoming,
'heads': rheads,
'source': 'incoming',
})
cg = fcg.result()
if localrepo: if localrepo:
bundletype = "HG10BZ" bundletype = "HG10BZ"
else: else:
bundletype = "HG10UN" bundletype = "HG10UN"
fname = bundle = bundle2.writebundle(ui, cg, bundlename, fname = bundle = bundle2.writebundle(ui, cg, bundlename,
bundletype) bundletype)
# keep written bundle? # keep written bundle?
if bundlename: if bundlename:

mercurial/exchange.py

# issue1320, avoid a race if remote changed after discovery # issue1320, avoid a race if remote changed after discovery
pullop.heads = pullop.rheads pullop.heads = pullop.rheads
if pullop.remote.capable('getbundle'): if pullop.remote.capable('getbundle'):
# TODO: get bundlecaps from remote # TODO: get bundlecaps from remote
cg = pullop.remote.getbundle('pull', common=pullop.common, cg = pullop.remote.getbundle('pull', common=pullop.common,
heads=pullop.heads or pullop.rheads) heads=pullop.heads or pullop.rheads)
elif pullop.heads is None: elif pullop.heads is None:
cg = pullop.remote.changegroup(pullop.fetch, 'pull') with pullop.remote.commandexecutor() as e:
fcg = e.callcommand('changegroup', {
'nodes': pullop.fetch,
'source': 'pull',
})
cg = fcg.result()
elif not pullop.remote.capable('changegroupsubset'): elif not pullop.remote.capable('changegroupsubset'):
raise error.Abort(_("partial pull cannot be done because " raise error.Abort(_("partial pull cannot be done because "
"other repository doesn't support " "other repository doesn't support "
"changegroupsubset.")) "changegroupsubset."))
else: else:
cg = pullop.remote.changegroupsubset(pullop.fetch, pullop.heads, 'pull') with pullop.remote.commandexecutor() as e:
fcg = e.callcommand('changegroupsubset', {
'bases': pullop.fetch,
'heads': pullop.heads,
'source': 'pull',
})
cg = fcg.result()
bundleop = bundle2.applybundle(pullop.repo, cg, tr, 'pull', bundleop = bundle2.applybundle(pullop.repo, cg, tr, 'pull',
pullop.remote.url()) pullop.remote.url())
pullop.cgresult = bundle2.combinechangegroupresults(bundleop) pullop.cgresult = bundle2.combinechangegroupresults(bundleop)
def _pullphase(pullop): def _pullphase(pullop):
# Get remote phases data from remote # Get remote phases data from remote
if 'phases' in pullop.stepsdone: if 'phases' in pullop.stepsdone:
return return

mercurial/localrepo.py

executor = localcommandexecutor(self) executor = localcommandexecutor(self)
try: try:
yield executor yield executor
finally: finally:
executor.close() executor.close()
# End of peer interface. # End of peer interface.
class locallegacypeer(repository.legacypeer, localpeer): @zi.implementer(repository.ipeerlegacycommands)
class locallegacypeer(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):
super(locallegacypeer, self).__init__(repo, caps=legacycaps) super(locallegacypeer, self).__init__(repo, caps=legacycaps)
# Begin of baselegacywirecommands interface. # Begin of baselegacywirecommands interface.
def between(self, pairs): def between(self, pairs):
return self._repo.between(pairs) return self._repo.between(pairs)
def branches(self, nodes): def branches(self, nodes):
return self._repo.branches(nodes) return self._repo.branches(nodes)
def changegroup(self, basenodes, source): def changegroup(self, nodes, source):
outgoing = discovery.outgoing(self._repo, missingroots=basenodes, outgoing = discovery.outgoing(self._repo, missingroots=nodes,
missingheads=self._repo.heads()) missingheads=self._repo.heads())
return changegroup.makechangegroup(self._repo, outgoing, '01', source) return changegroup.makechangegroup(self._repo, outgoing, '01', source)
def changegroupsubset(self, bases, heads, source): def changegroupsubset(self, bases, heads, source):
outgoing = discovery.outgoing(self._repo, missingroots=bases, outgoing = discovery.outgoing(self._repo, missingroots=bases,
missingheads=heads) missingheads=heads)
return changegroup.makechangegroup(self._repo, outgoing, '01', source) return changegroup.makechangegroup(self._repo, outgoing, '01', source)

mercurial/repository.py

"""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.
""" """
def changegroup(nodes, kind): def changegroup(nodes, source):
"""Obtain a changegroup with data for descendants of specified nodes.""" """Obtain a changegroup with data for descendants of specified nodes."""
def changegroupsubset(bases, heads, kind): def changegroupsubset(bases, heads, source):
pass pass
class ipeercommandexecutor(zi.Interface): class ipeercommandexecutor(zi.Interface):
"""Represents a mechanism to execute remote commands. """Represents a mechanism to execute remote commands.
This is the primary interface for requesting that wire protocol commands This is the primary interface for requesting that wire protocol commands
be executed. Instances of this interface are active in a context manager be executed. Instances of this interface are active in a context manager
and have a well-defined lifetime. When the context manager exits, all and have a well-defined lifetime. When the context manager exits, all
class ipeerbase(ipeerconnection, ipeercapabilities, ipeercommands, class ipeerbase(ipeerconnection, ipeercapabilities, ipeercommands,
ipeerrequests): ipeerrequests):
"""Unified interface for peer repositories. """Unified interface for peer repositories.
All peer instances must conform to this interface. All peer instances must conform to this interface.
""" """
class ipeerbaselegacycommands(ipeerbase, ipeerlegacycommands):
"""Unified peer interface that supports legacy commands."""
@zi.implementer(ipeerbase) @zi.implementer(ipeerbase)
class peer(object): class peer(object):
"""Base class for peer repositories.""" """Base class for peer repositories."""
def capable(self, name): 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):
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))
@zi.implementer(ipeerbaselegacycommands)
class legacypeer(peer):
"""peer but with support for legacy wire protocol commands."""
class ifilerevisionssequence(zi.Interface): class ifilerevisionssequence(zi.Interface):
"""Contains index data for all revisions of a file. """Contains index data for all revisions of a file.
Types implementing this behave like lists of tuples. The index Types implementing this behave like lists of tuples. The index
in the list corresponds to the revision number. The values contain in the list corresponds to the revision number. The values contain
index metadata. index metadata.
The *null* revision (revision number -1) is always the last item The *null* revision (revision number -1) is always the last item

mercurial/wireprotov1peer.py

# And ask the coroutine to decode that value. # And ask the coroutine to decode that value.
try: try:
result = next(batchable) result = next(batchable)
except Exception: except Exception:
f.set_exception_info(*sys.exc_info()[1:]) f.set_exception_info(*sys.exc_info()[1:])
else: else:
f.set_result(result) f.set_result(result)
class wirepeer(repository.legacypeer): @zi.implementer(repository.ipeerlegacycommands)
class wirepeer(repository.peer):
"""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.
""" """
@contextlib.contextmanager @contextlib.contextmanager
d = self._call("between", pairs=n) d = self._call("between", pairs=n)
try: try:
r.extend(l and wireprototypes.decodelist(l) or [] r.extend(l and wireprototypes.decodelist(l) or []
for l in d.splitlines()) for l in d.splitlines())
except ValueError: except ValueError:
self._abort(error.ResponseError(_("unexpected response:"), d)) self._abort(error.ResponseError(_("unexpected response:"), d))
return r return r
def changegroup(self, nodes, kind): def changegroup(self, nodes, source):
n = wireprototypes.encodelist(nodes) n = wireprototypes.encodelist(nodes)
f = self._callcompressable("changegroup", roots=n) f = self._callcompressable("changegroup", roots=n)
return changegroupmod.cg1unpacker(f, 'UN') return changegroupmod.cg1unpacker(f, 'UN')
def changegroupsubset(self, bases, heads, kind): def changegroupsubset(self, bases, heads, source):
self.requirecap('changegroupsubset', _('look up remote changes')) self.requirecap('changegroupsubset', _('look up remote changes'))
bases = wireprototypes.encodelist(bases) bases = wireprototypes.encodelist(bases)
heads = wireprototypes.encodelist(heads) heads = wireprototypes.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 ipeerlegacycommands interface. # End of ipeerlegacycommands interface.

tests/test-check-interfaces.py

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)
checkzobject(badpeer()) checkzobject(badpeer())
ziverify.verifyClass(repository.ipeerbaselegacycommands, ziverify.verifyClass(repository.ipeerbase, httppeer.httppeer)
httppeer.httppeer)
checkzobject(httppeer.httppeer(None, None, None, dummyopener(), None, None)) checkzobject(httppeer.httppeer(None, None, None, dummyopener(), None, None))
ziverify.verifyClass(repository.ipeerconnection, ziverify.verifyClass(repository.ipeerconnection,
httppeer.httpv2peer) httppeer.httpv2peer)
ziverify.verifyClass(repository.ipeercapabilities, ziverify.verifyClass(repository.ipeercapabilities,
httppeer.httpv2peer) httppeer.httpv2peer)
checkzobject(httppeer.httpv2peer(None, '', None, None, None, None)) checkzobject(httppeer.httpv2peer(None, '', None, None, None, None))
ziverify.verifyClass(repository.ipeerbase, ziverify.verifyClass(repository.ipeerbase,
localrepo.localpeer) localrepo.localpeer)
checkzobject(localrepo.localpeer(dummyrepo())) checkzobject(localrepo.localpeer(dummyrepo()))
ziverify.verifyClass(repository.ipeercommandexecutor, ziverify.verifyClass(repository.ipeercommandexecutor,
localrepo.localcommandexecutor) localrepo.localcommandexecutor)
checkzobject(localrepo.localcommandexecutor(None)) checkzobject(localrepo.localcommandexecutor(None))
ziverify.verifyClass(repository.ipeercommandexecutor, ziverify.verifyClass(repository.ipeercommandexecutor,
wireprotov1peer.peerexecutor) wireprotov1peer.peerexecutor)
checkzobject(wireprotov1peer.peerexecutor(None)) checkzobject(wireprotov1peer.peerexecutor(None))
ziverify.verifyClass(repository.ipeerbaselegacycommands, ziverify.verifyClass(repository.ipeerbase, sshpeer.sshv1peer)
sshpeer.sshv1peer)
checkzobject(sshpeer.sshv1peer(ui, 'ssh://localhost/foo', None, dummypipe(), checkzobject(sshpeer.sshv1peer(ui, 'ssh://localhost/foo', None, dummypipe(),
dummypipe(), None, None)) dummypipe(), None, None))
ziverify.verifyClass(repository.ipeerbaselegacycommands, ziverify.verifyClass(repository.ipeerbase, sshpeer.sshv2peer)
sshpeer.sshv2peer)
checkzobject(sshpeer.sshv2peer(ui, 'ssh://localhost/foo', None, dummypipe(), checkzobject(sshpeer.sshv2peer(ui, 'ssh://localhost/foo', None, dummypipe(),
dummypipe(), None, None)) dummypipe(), None, None))
ziverify.verifyClass(repository.ipeerbase, bundlerepo.bundlepeer) ziverify.verifyClass(repository.ipeerbase, bundlerepo.bundlepeer)
checkzobject(bundlerepo.bundlepeer(dummyrepo())) checkzobject(bundlerepo.bundlepeer(dummyrepo()))
ziverify.verifyClass(repository.ipeerbase, statichttprepo.statichttppeer) ziverify.verifyClass(repository.ipeerbase, statichttprepo.statichttppeer)
checkzobject(statichttprepo.statichttppeer(dummyrepo())) checkzobject(statichttprepo.statichttppeer(dummyrepo()))