This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9973

wireprotopeer: clarify some variable names now that we allow snake_case
ClosedPublic

Authored by martinvonz on Feb 9 2021, 12:41 PM.

Details

Reviewers
SimonSapin
pulkit
Group Reviewers
hg-reviewers
Commits
rHG05dd091dfa6a: wireprotopeer: clarify some variable names now that we allow snake_case
Summary

"encargsorres" is hard to parse ("encarg sorres" sounds like it might
be Spanish to me, and indeed Google Translate tells me that it's
Catalan for "order sands"). Let's clarify with some added underscores
and longer names.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

martinvonz created this revision.Feb 9 2021, 12:41 PM
SimonSapin accepted this revision.Feb 10 2021, 4:32 AM
pulkit accepted this revision.Feb 10 2021, 7:04 AM
This revision is now accepted and ready to land.Feb 10 2021, 7:04 AM

Revision Contents
Changeset List

Diff 25525

mercurial/httppeer.py

assert cmd != b'capabilities' assert cmd != b'capabilities'
httpheader = capablefn(b'httpheader') httpheader = capablefn(b'httpheader')
if httpheader: if httpheader:
headersize = int(httpheader.split(b',', 1)[0]) headersize = int(httpheader.split(b',', 1)[0])
# Send arguments via HTTP headers. # Send arguments via HTTP headers.
if headersize > 0: if headersize > 0:
# The headers can typically carry more data than the URL. # The headers can typically carry more data than the URL.
encargs = urlreq.urlencode(sorted(args.items())) encoded_args = urlreq.urlencode(sorted(args.items()))
for header, value in encodevalueinheaders( for header, value in encodevalueinheaders(
encargs, b'X-HgArg', headersize encoded_args, b'X-HgArg', headersize
): ):
headers[header] = value headers[header] = value
# Send arguments via query string (Mercurial <1.9). # Send arguments via query string (Mercurial <1.9).
else: else:
q += sorted(args.items()) q += sorted(args.items())
qs = b'?%s' % urlreq.urlencode(q) qs = b'?%s' % urlreq.urlencode(q)
cu = b"%s%s" % (repobaseurl, qs) cu = b"%s%s" % (repobaseurl, qs)

mercurial/wireprotov1peer.py

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):
# Build list of encoded arguments suitable for your wire protocol: # Build list of encoded arguments suitable for your wire protocol:
encargs = [('one', encode(one),), ('two', encode(two),)] encoded_args = [('one', encode(one),), ('two', encode(two),)]
# Create future for injection of encoded result: # Create future for injection of encoded result:
encresref = future() encoded_res_future = future()
# Return encoded arguments and future: # Return encoded arguments and future:
yield encargs, encresref yield encoded_args, encoded_res_future
# Assuming the future to be filled with the result from the batched # Assuming the future to be filled with the result from the batched
# request now. Decode it: # request now. Decode it:
yield decode(encresref.value) yield decode(encoded_res_future.value)
The decorator returns a function which wraps this coroutine as a plain The decorator returns a function which wraps this coroutine as a plain
method, but adds the original method as an attribute called "batchable", method, but adds the original method as an attribute called "batchable",
which is used by remotebatch to split the call into separate encoding and which is used by remotebatch to split the call into separate encoding and
decoding phases. decoding phases.
""" """
def plain(*args, **opts): def plain(*args, **opts):
batchable = f(*args, **opts) batchable = f(*args, **opts)
encargsorres, encresref = next(batchable) encoded_args_or_res, encoded_res_future = next(batchable)
if not encresref: if not encoded_res_future:
return encargsorres # a local result in this case return encoded_args_or_res # a local result in this case
self = args[0] self = args[0]
cmd = pycompat.bytesurl(f.__name__) # ensure cmd is ascii bytestr cmd = pycompat.bytesurl(f.__name__) # ensure cmd is ascii bytestr
encresref.set(self._submitone(cmd, encargsorres)) encoded_res_future.set(self._submitone(cmd, encoded_args_or_res))
return next(batchable) return next(batchable)
setattr(plain, 'batchable', f) setattr(plain, 'batchable', f)
setattr(plain, '__name__', f.__name__) setattr(plain, '__name__', f.__name__)
return plain return plain
class future(object): class future(object):
fn.__self__, **pycompat.strkwargs(args) fn.__self__, **pycompat.strkwargs(args)
) )
except Exception: except Exception:
pycompat.future_set_exception_info(f, sys.exc_info()[1:]) pycompat.future_set_exception_info(f, sys.exc_info()[1:])
return return
# Encoded arguments and future holding remote result. # Encoded arguments and future holding remote result.
try: try:
encargsorres, fremote = next(batchable) encoded_args_or_res, fremote = next(batchable)
except Exception: except Exception:
pycompat.future_set_exception_info(f, sys.exc_info()[1:]) pycompat.future_set_exception_info(f, sys.exc_info()[1:])
return return
if not fremote: if not fremote:
f.set_result(encargsorres) f.set_result(encoded_args_or_res)
else: else:
requests.append((command, encargsorres)) requests.append((command, encoded_args_or_res))
states.append((command, f, batchable, fremote)) states.append((command, f, batchable, fremote))
if not requests: if not requests:
return return
# This will emit responses in order they were executed. # This will emit responses in order they were executed.
wireresults = self._peer._submitbatch(requests) wireresults = self._peer._submitbatch(requests)

tests/test-batching.py

e = wireprotov1peer.peerexecutor(self) e = wireprotov1peer.peerexecutor(self)
try: try:
yield e yield e
finally: finally:
e.close() e.close()
@wireprotov1peer.batchable @wireprotov1peer.batchable
def foo(self, one, two=None): def foo(self, one, two=None):
encargs = [ encoded_args = [
( (
b'one', b'one',
mangle(one), mangle(one),
), ),
( (
b'two', b'two',
mangle(two), mangle(two),
), ),
] ]
encresref = wireprotov1peer.future() encoded_res_future = wireprotov1peer.future()
yield encargs, encresref yield encoded_args, encoded_res_future
yield unmangle(encresref.value) yield unmangle(encoded_res_future.value)
@wireprotov1peer.batchable @wireprotov1peer.batchable
def bar(self, b, a): def bar(self, b, a):
encresref = wireprotov1peer.future() encresref = wireprotov1peer.future()
yield [ yield [
( (
b'b', b'b',
mangle(b), mangle(b),