This is an archive of the discontinued Mercurial Phabricator instance.

Differential D3380

wireprotov2: establish a type for representing command response
ClosedPublic

Authored by indygreg on Apr 14 2018, 8:21 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHGd715a85003c8: wireprotov2: establish a type for representing command response
Summary

It will be desirable to have a higher-level type for representing
command responses. This will allow us to do nicer things.

For now, the instance encapsulates existing logic. It is still
a bit primitive. But we're slowly making things better.

Version 1 protocols have a wrapping layer that decodes the raw
string data into a data structure and that data structure is
sent to the future. Version 2 doesn't yet have this layer and
the future is receiving the raw wire response. Hence why
debugcommands needed to be taught about the response type.

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

indygreg created this revision.Apr 14 2018, 8:21 PM
durin42 accepted this revision.Apr 16 2018, 6:52 PM
This revision is now accepted and ready to land.Apr 16 2018, 6:52 PM
Closed by commit rHGd715a85003c8: wireprotov2: establish a type for representing command response (authored by indygreg). · Explain WhyApr 16 2018, 7:09 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/debugcommands.py (12 lines)
Mmercurial/wireprotov2peer.py (46 lines)

Diff 8323

mercurial/debugcommands.py

templater, templater,
treediscovery, treediscovery,
upgrade, upgrade,
url as urlmod, url as urlmod,
util, util,
vfs as vfsmod, vfs as vfsmod,
wireprotoframing, wireprotoframing,
wireprotoserver, wireprotoserver,
wireprotov2peer,
) )
from .utils import ( from .utils import (
dateutil, dateutil,
procutil, procutil,
stringutil, stringutil,
) )
release = lockmod.release release = lockmod.release
**pycompat.strkwargs(args)) **pycompat.strkwargs(args))
ui.status(_('result: %s\n') % stringutil.escapestr(res)) ui.status(_('result: %s\n') % stringutil.escapestr(res))
ui.status(_('remote output: %s\n') % ui.status(_('remote output: %s\n') %
stringutil.escapestr(output)) stringutil.escapestr(output))
else: else:
with peer.commandexecutor() as e: with peer.commandexecutor() as e:
res = e.callcommand(command, args).result() res = e.callcommand(command, args).result()
if isinstance(res, wireprotov2peer.commandresponse):
if res.cbor:
val = list(res.cborobjects())
else:
val = [res.b.getvalue()]
ui.status(_('response: %s\n') % stringutil.pprint(val))
else:
ui.status(_('response: %s\n') % stringutil.pprint(res)) ui.status(_('response: %s\n') % stringutil.pprint(res))
elif action == 'batchbegin': elif action == 'batchbegin':
if batchedcommands is not None: if batchedcommands is not None:
raise error.Abort(_('nested batchbegin not allowed')) raise error.Abort(_('nested batchbegin not allowed'))
batchedcommands = [] batchedcommands = []
elif action == 'batchsubmit': elif action == 'batchsubmit':
# There is a batching API we could go through. But it would be # There is a batching API we could go through. But it would be

mercurial/wireprotov2peer.py

cbor, cbor,
) )
from . import ( from . import (
error, error,
util, util,
wireprotoframing, wireprotoframing,
) )
class commandresponse(object):
"""Represents the response to a command request."""
def __init__(self, requestid, command):
self.requestid = requestid
self.command = command
self.cbor = False
self.b = util.bytesio()
def cborobjects(self):
"""Obtain decoded CBOR objects from this response."""
size = self.b.tell()
self.b.seek(0)
decoder = cbor.CBORDecoder(self.b)
while self.b.tell() < size:
yield decoder.decode()
class clienthandler(object): class clienthandler(object):
"""Object to handle higher-level client activities. """Object to handle higher-level client activities.
The ``clientreactor`` is used to hold low-level state about the frame-based The ``clientreactor`` is used to hold low-level state about the frame-based
protocol, such as which requests and streams are active. This type is used protocol, such as which requests and streams are active. This type is used
for higher-level operations, such as reading frames from a socket, exposing for higher-level operations, such as reading frames from a socket, exposing
and managing a higher-level primitive for representing command responses, and managing a higher-level primitive for representing command responses,
etc. This class is what peers should probably use to bridge wire activity etc. This class is what peers should probably use to bridge wire activity
request, action, meta = self._reactor.callcommand(command, args) request, action, meta = self._reactor.callcommand(command, args)
if action != 'noop': if action != 'noop':
raise error.ProgrammingError('%s not yet supported' % action) raise error.ProgrammingError('%s not yet supported' % action)
rid = request.requestid rid = request.requestid
self._requests[rid] = request self._requests[rid] = request
self._futures[rid] = f self._futures[rid] = f
self._responses[rid] = { self._responses[rid] = commandresponse(rid, command)
'cbor': False,
'b': util.bytesio(),
}
return iter(()) return iter(())
def flushcommands(self): def flushcommands(self):
"""Flush all queued commands. """Flush all queued commands.
Returns an iterable of frames that should be sent over the wire. Returns an iterable of frames that should be sent over the wire.
""" """
raise error.ProgrammingError( raise error.ProgrammingError(
'received frame for unknown request; this is either a bug in ' 'received frame for unknown request; this is either a bug in '
'the clientreactor not screening for this or this instance was ' 'the clientreactor not screening for this or this instance was '
'never told about this request: %r' % frame) 'never told about this request: %r' % frame)
response = self._responses[frame.requestid] response = self._responses[frame.requestid]
if action == 'responsedata': if action == 'responsedata':
response['b'].write(meta['data']) response.b.write(meta['data'])
if meta['cbor']: if meta['cbor']:
response['cbor'] = True response.cbor = True
if meta['eos']: if meta['eos']:
if meta['cbor']: self._futures[frame.requestid].set_result(response)
# If CBOR, decode every object.
b = response['b']
size = b.tell()
b.seek(0)
decoder = cbor.CBORDecoder(b)
result = []
while b.tell() < size:
result.append(decoder.decode())
else:
result = [response['b'].getvalue()]
self._futures[frame.requestid].set_result(result)
del self._requests[frame.requestid] del self._requests[frame.requestid]
del self._futures[frame.requestid] del self._futures[frame.requestid]
else: else:
raise error.ProgrammingError( raise error.ProgrammingError(
'unhandled action from clientreactor: %s' % action) 'unhandled action from clientreactor: %s' % action)