( )⚙ D319 wireproto: overhaul iterating batcher code (API)

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D319

wireproto: overhaul iterating batcher code (API)
ClosedPublic

Authored by indygreg on Aug 10 2017, 2:47 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG4c706037adef: wireproto: overhaul iterating batcher code (API)
Summary

The remote batching code is difficult to read. Let's improve it.

As part of the refactor, the future returned by method calls on
batchiter() instances is now populated. However, you still need to
consume the results() generator for the future to be set. But at
least now we can stuff the future somewhere and not have to worry
about aligning method call order with result order since you can
use a future to hold the result.

Also as part of the change, we now verify that @batchable generators
yield exactly 2 values. In other words, we enforce their API.

The non-iter batcher has been unused since b6e71f8af5b8. And to my
surprise we had no explicit unit test coverage of it! test-batching.py
has been overhauled to use the iterating batcher.

Since the iterating batcher doesn't allow non-batchable method
calls nor local calls, tests have been updated to reflect reality.
The iterating batcher has been used for multiple releases apparently
without major issue. So this shouldn't cause alarm.

.. api::

@peer.batchable functions must now yield exactly 2 values

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Revision Contents
Changeset List

PathPackages
Mmercurial/peer.py (3 lines)
Mmercurial/wireproto.py (52 lines)
Mtests/test-batching.py (64 lines)
Mtests/test-batching.py.out (16 lines)

Diff 734

mercurial/peer.py

self.local = local self.local = local
def submit(self): def submit(self):
# submit for a local iter batcher is a noop # submit for a local iter batcher is a noop
pass pass
def results(self): def results(self):
for name, args, opts, resref in self.calls: for name, args, opts, resref in self.calls:
yield getattr(self.local, name)(*args, **opts) resref.set(getattr(self.local, name)(*args, **opts))
yield resref.value
def batchable(f): def batchable(f):
'''annotation for batchable methods '''annotation for batchable methods
Such methods must implement a coroutine as follows: Such methods must implement a coroutine as follows:
@batchable @batchable
def sample(self, one, two=None): def sample(self, one, two=None):

mercurial/wireproto.py

return super(remoteiterbatcher, self).__getattr__(name) return super(remoteiterbatcher, self).__getattr__(name)
def submit(self): def submit(self):
"""Break the batch request into many patch calls and pipeline them. """Break the batch request into many patch calls and pipeline them.
This is mostly valuable over http where request sizes can be This is mostly valuable over http where request sizes can be
limited, but can be used in other places as well. limited, but can be used in other places as well.
""" """
req, rsp = [], [] # 2-tuple of (command, arguments) that represents what will be
for name, args, opts, resref in self.calls: # sent over the wire.
mtd = getattr(self._remote, name) requests = []
# 4-tuple of (command, final future, @batchable generator, remote
# future).
results = []
for command, args, opts, finalfuture in self.calls:
mtd = getattr(self._remote, command)
batchable = mtd.batchable(mtd.im_self, *args, **opts) batchable = mtd.batchable(mtd.im_self, *args, **opts)
encargsorres, encresref = next(batchable)
assert encresref commandargs, fremote = next(batchable)
req.append((name, encargsorres)) assert fremote
rsp.append((batchable, encresref)) requests.append((command, commandargs))
if req: results.append((command, finalfuture, batchable, fremote))
self._resultiter = self._remote._submitbatch(req)
self._rsp = rsp if requests:
self._resultiter = self._remote._submitbatch(requests)
self._results = results
def results(self): def results(self):
for (batchable, encresref), encres in itertools.izip( for command, finalfuture, batchable, remotefuture in self._results:
self._rsp, self._resultiter): # Get the raw result, set it in the remote future, feed it
encresref.set(encres) # back into the @batchable generator so it can be decoded, and
yield next(batchable) # set the result on the final future to this value.
remoteresult = next(self._resultiter)
remotefuture.set(remoteresult)
finalfuture.set(next(batchable))
# Verify our @batchable generators only emit 2 values.
try:
next(batchable)
except StopIteration:
pass
else:
raise error.ProgrammingError('%s @batchable generator emitted '
'unexpected value count' % command)
yield finalfuture.value
# Forward a couple of names from peer to make wireproto interactions # Forward a couple of names from peer to make wireproto interactions
# slightly more sensible. # slightly more sensible.
batchable = peer.batchable batchable = peer.batchable
future = peer.future future = peer.future
# list of nodes encoding / decoding # list of nodes encoding / decoding

tests/test-batching.py

# test-batching.py - tests for transparent command batching # test-batching.py - tests for transparent command batching
# #
# Copyright 2011 Peter Arrenbrecht <peter@arrenbrecht.ch> # Copyright 2011 Peter Arrenbrecht <peter@arrenbrecht.ch>
# #
# 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, print_function from __future__ import absolute_import, print_function
from mercurial import ( from mercurial import (
error,
peer, peer,
util,
wireproto, wireproto,
) )
# equivalent of repo.repository # equivalent of repo.repository
class thing(object): class thing(object):
def hello(self): def hello(self):
return "Ready." return "Ready."
# equivalent of localrepo.localrepository # equivalent of localrepo.localrepository
class localthing(thing): class localthing(thing):
def foo(self, one, two=None): def foo(self, one, two=None):
if one: if one:
return "%s and %s" % (one, two,) return "%s and %s" % (one, two,)
return "Nope" return "Nope"
def bar(self, b, a): def bar(self, b, a):
return "%s und %s" % (b, a,) return "%s und %s" % (b, a,)
def greet(self, name=None): def greet(self, name=None):
return "Hello, %s" % name return "Hello, %s" % name
def batch(self): def batchiter(self):
'''Support for local batching.''' '''Support for local batching.'''
return peer.localbatch(self) return peer.localiterbatcher(self)
# usage of "thing" interface # usage of "thing" interface
def use(it): def use(it):
# Direct call to base method shared between client and server. # Direct call to base method shared between client and server.
print(it.hello()) print(it.hello())
# Direct calls to proxied methods. They cause individual roundtrips. # Direct calls to proxied methods. They cause individual roundtrips.
print(it.foo("Un", two="Deux")) print(it.foo("Un", two="Deux"))
print(it.bar("Eins", "Zwei")) print(it.bar("Eins", "Zwei"))
# Batched call to a couple of (possibly proxied) methods. # Batched call to a couple of proxied methods.
batch = it.batch() batch = it.batchiter()
# The calls return futures to eventually hold results. # The calls return futures to eventually hold results.
foo = batch.foo(one="One", two="Two") foo = batch.foo(one="One", two="Two")
bar = batch.bar("Eins", "Zwei") bar = batch.bar("Eins", "Zwei")
# We can call non-batchable proxy methods, but the break the current batch
# request and cause additional roundtrips.
greet = batch.greet(name="John Smith")
# We can also add local methods into the mix, but they break the batch too.
hello = batch.hello()
bar2 = batch.bar(b="Uno", a="Due") bar2 = batch.bar(b="Uno", a="Due")
# Only now are all the calls executed in sequence, with as few roundtrips
# as possible. # Future shouldn't be set until we submit().
assert isinstance(foo, peer.future)
assert not util.safehasattr(foo, 'value')
assert not util.safehasattr(bar, 'value')
batch.submit() batch.submit()
# After the call to submit, the futures actually contain values. # Call results() to obtain results as a generator.
results = batch.results()
# Future results shouldn't be set until we consume a value.
assert not util.safehasattr(foo, 'value')
foovalue = next(results)
assert util.safehasattr(foo, 'value')
assert foovalue == foo.value
print(foo.value) print(foo.value)
next(results)
print(bar.value) print(bar.value)
print(greet.value) next(results)
print(hello.value)
print(bar2.value) print(bar2.value)
# We should be at the end of the results generator.
try:
next(results)
except StopIteration:
print('proper end of results generator')
else:
print('extra emitted element!')
# Attempting to call a non-batchable method inside a batch fails.
batch = it.batchiter()
try:
batch.greet(name='John Smith')
except error.ProgrammingError as e:
print(e)
# Attempting to call a local method inside a batch fails.
batch = it.batchiter()
try:
batch.hello()
except error.ProgrammingError as e:
print(e)
# local usage # local usage
mylocal = localthing() mylocal = localthing()
print() print()
print("== Local") print("== Local")
use(mylocal) use(mylocal)
# demo remoting; mimicks what wireproto and HTTP/SSH do # demo remoting; mimicks what wireproto and HTTP/SSH do
return self.server.perform(req) return self.server.perform(req)
def _submitbatch(self, cmds): def _submitbatch(self, cmds):
req = [] req = []
for name, args in cmds: for name, args in cmds:
args = ','.join(n + '=' + escapearg(v) for n, v in args) args = ','.join(n + '=' + escapearg(v) for n, v in args)
req.append(name + ':' + args) req.append(name + ':' + args)
req = ';'.join(req) req = ';'.join(req)
res = self._submitone('batch', [('cmds', req,)]) res = self._submitone('batch', [('cmds', req,)])
return res.split(';') for r in res.split(';'):
yield r
def batch(self): def batchiter(self):
return wireproto.remotebatch(self) return wireproto.remoteiterbatcher(self)
@peer.batchable @peer.batchable
def foo(self, one, two=None): def foo(self, one, two=None):
encargs = [('one', mangle(one),), ('two', mangle(two),)] encargs = [('one', mangle(one),), ('two', mangle(two),)]
encresref = peer.future() encresref = peer.future()
yield encargs, encresref yield encargs, encresref
yield unmangle(encresref.value) yield unmangle(encresref.value)

tests/test-batching.py.out

== Local == Local
Ready. Ready.
Un and Deux Un and Deux
Eins und Zwei Eins und Zwei
One and Two One and Two
Eins und Zwei Eins und Zwei
Hello, John Smith
Ready.
Uno und Due Uno und Due
proper end of results generator
== Remote == Remote
Ready. Ready.
REQ: foo?one=Vo&two=Efvy REQ: foo?one=Vo&two=Efvy
-> Vo!boe!Efvy -> Vo!boe!Efvy
Un and Deux Un and Deux
REQ: bar?b=Fjot&a=[xfj REQ: bar?b=Fjot&a=[xfj
-> Fjot!voe![xfj -> Fjot!voe![xfj
Eins und Zwei Eins und Zwei
REQ: batch?cmds=foo:one=Pof,two=Uxp;bar:b=Fjot,a=[xfj REQ: batch?cmds=foo:one=Pof,two=Uxp;bar:b=Fjot,a=[xfj;bar:b=Vop,a=Evf
-> Pof!boe!Uxp;Fjot!voe![xfj -> Pof!boe!Uxp;Fjot!voe![xfj;Vop!voe!Evf
REQ: greet?name=Kpio!Tnjui
-> Ifmmp-!Kpio!Tnjui
REQ: batch?cmds=bar:b=Vop,a=Evf
-> Vop!voe!Evf
One and Two One and Two
Eins und Zwei Eins und Zwei
Hello, John Smith
Ready.
Uno und Due Uno und Due
proper end of results generator
Attempted to batch a non-batchable call to 'greet'
Attempted to batch a non-batchable call to 'hello'