This is an archive of the discontinued Mercurial Phabricator instance.

Differential D3384

wireprotov2: change frame type and name for command response
ClosedPublic

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

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHGdeff7cf7eefd: wireprotov2: change frame type and name for command response
Summary

There was hole at frame type value 3. And the frame is better
named as a command response.

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 rHGdeff7cf7eefd: wireprotov2: change frame type and name for command response (authored by indygreg). · Explain WhyApr 16 2018, 7:10 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 8327

mercurial/help/internals/wireprotocol.txt

Command data continuation. When set, the data for this command Command data continuation. When set, the data for this command
continues into a subsequent frame. continues into a subsequent frame.
0x02 0x02
End of data. When set, command data has been fully sent to the End of data. When set, command data has been fully sent to the
server. The command has been fully issued and no new data for this server. The command has been fully issued and no new data for this
command will be sent. The next frame will belong to a new command. command will be sent. The next frame will belong to a new command.
Response Data (``0x04``) Command Response Data (``0x03``)
------------------------ --------------------------------
This frame contains response data to an issued command. This frame contains response data to an issued command.
Response data ALWAYS consists of a series of 0 or more CBOR encoded Response data ALWAYS consists of a series of 0 or more CBOR encoded
values. A CBOR value may be using indefinite length encoding. And the values. A CBOR value may be using indefinite length encoding. And the
bytes constituting the value may span several frames. bytes constituting the value may span several frames.
The following flag values are defined for this type: The following flag values are defined for this type:

mercurial/wireprotoframing.py

STREAM_FLAGS = { STREAM_FLAGS = {
b'stream-begin': STREAM_FLAG_BEGIN_STREAM, b'stream-begin': STREAM_FLAG_BEGIN_STREAM,
b'stream-end': STREAM_FLAG_END_STREAM, b'stream-end': STREAM_FLAG_END_STREAM,
b'encoded': STREAM_FLAG_ENCODING_APPLIED, b'encoded': STREAM_FLAG_ENCODING_APPLIED,
} }
FRAME_TYPE_COMMAND_REQUEST = 0x01 FRAME_TYPE_COMMAND_REQUEST = 0x01
FRAME_TYPE_COMMAND_DATA = 0x02 FRAME_TYPE_COMMAND_DATA = 0x02
FRAME_TYPE_BYTES_RESPONSE = 0x04 FRAME_TYPE_COMMAND_RESPONSE = 0x03
FRAME_TYPE_ERROR_RESPONSE = 0x05 FRAME_TYPE_ERROR_RESPONSE = 0x05
FRAME_TYPE_TEXT_OUTPUT = 0x06 FRAME_TYPE_TEXT_OUTPUT = 0x06
FRAME_TYPE_PROGRESS = 0x07 FRAME_TYPE_PROGRESS = 0x07
FRAME_TYPE_STREAM_SETTINGS = 0x08 FRAME_TYPE_STREAM_SETTINGS = 0x08
FRAME_TYPES = { FRAME_TYPES = {
b'command-request': FRAME_TYPE_COMMAND_REQUEST, b'command-request': FRAME_TYPE_COMMAND_REQUEST,
b'command-data': FRAME_TYPE_COMMAND_DATA, b'command-data': FRAME_TYPE_COMMAND_DATA,
b'bytes-response': FRAME_TYPE_BYTES_RESPONSE, b'command-response': FRAME_TYPE_COMMAND_RESPONSE,
b'error-response': FRAME_TYPE_ERROR_RESPONSE, b'error-response': FRAME_TYPE_ERROR_RESPONSE,
b'text-output': FRAME_TYPE_TEXT_OUTPUT, b'text-output': FRAME_TYPE_TEXT_OUTPUT,
b'progress': FRAME_TYPE_PROGRESS, b'progress': FRAME_TYPE_PROGRESS,
b'stream-settings': FRAME_TYPE_STREAM_SETTINGS, b'stream-settings': FRAME_TYPE_STREAM_SETTINGS,
} }
FLAG_COMMAND_REQUEST_NEW = 0x01 FLAG_COMMAND_REQUEST_NEW = 0x01
FLAG_COMMAND_REQUEST_CONTINUATION = 0x02 FLAG_COMMAND_REQUEST_CONTINUATION = 0x02
FLAG_COMMAND_DATA_CONTINUATION = 0x01 FLAG_COMMAND_DATA_CONTINUATION = 0x01
FLAG_COMMAND_DATA_EOS = 0x02 FLAG_COMMAND_DATA_EOS = 0x02
FLAGS_COMMAND_DATA = { FLAGS_COMMAND_DATA = {
b'continuation': FLAG_COMMAND_DATA_CONTINUATION, b'continuation': FLAG_COMMAND_DATA_CONTINUATION,
b'eos': FLAG_COMMAND_DATA_EOS, b'eos': FLAG_COMMAND_DATA_EOS,
} }
FLAG_BYTES_RESPONSE_CONTINUATION = 0x01 FLAG_COMMAND_RESPONSE_CONTINUATION = 0x01
FLAG_BYTES_RESPONSE_EOS = 0x02 FLAG_COMMAND_RESPONSE_EOS = 0x02
FLAGS_BYTES_RESPONSE = { FLAGS_COMMAND_RESPONSE = {
b'continuation': FLAG_BYTES_RESPONSE_CONTINUATION, b'continuation': FLAG_COMMAND_RESPONSE_CONTINUATION,
b'eos': FLAG_BYTES_RESPONSE_EOS, b'eos': FLAG_COMMAND_RESPONSE_EOS,
} }
FLAG_ERROR_RESPONSE_PROTOCOL = 0x01 FLAG_ERROR_RESPONSE_PROTOCOL = 0x01
FLAG_ERROR_RESPONSE_APPLICATION = 0x02 FLAG_ERROR_RESPONSE_APPLICATION = 0x02
FLAGS_ERROR_RESPONSE = { FLAGS_ERROR_RESPONSE = {
b'protocol': FLAG_ERROR_RESPONSE_PROTOCOL, b'protocol': FLAG_ERROR_RESPONSE_PROTOCOL,
b'application': FLAG_ERROR_RESPONSE_APPLICATION, b'application': FLAG_ERROR_RESPONSE_APPLICATION,
} }
# Maps frame types to their available flags. # Maps frame types to their available flags.
FRAME_TYPE_FLAGS = { FRAME_TYPE_FLAGS = {
FRAME_TYPE_COMMAND_REQUEST: FLAGS_COMMAND_REQUEST, FRAME_TYPE_COMMAND_REQUEST: FLAGS_COMMAND_REQUEST,
FRAME_TYPE_COMMAND_DATA: FLAGS_COMMAND_DATA, FRAME_TYPE_COMMAND_DATA: FLAGS_COMMAND_DATA,
FRAME_TYPE_BYTES_RESPONSE: FLAGS_BYTES_RESPONSE, FRAME_TYPE_COMMAND_RESPONSE: FLAGS_COMMAND_RESPONSE,
FRAME_TYPE_ERROR_RESPONSE: FLAGS_ERROR_RESPONSE, FRAME_TYPE_ERROR_RESPONSE: FLAGS_ERROR_RESPONSE,
FRAME_TYPE_TEXT_OUTPUT: {}, FRAME_TYPE_TEXT_OUTPUT: {},
FRAME_TYPE_PROGRESS: {}, FRAME_TYPE_PROGRESS: {},
FRAME_TYPE_STREAM_SETTINGS: {}, FRAME_TYPE_STREAM_SETTINGS: {},
} }
ARGUMENT_RECORD_HEADER = struct.Struct(r'<HH') ARGUMENT_RECORD_HEADER = struct.Struct(r'<HH')
yield stream.makeframe(requestid=requestid, yield stream.makeframe(requestid=requestid,
typeid=FRAME_TYPE_COMMAND_DATA, typeid=FRAME_TYPE_COMMAND_DATA,
flags=flags, flags=flags,
payload=data) payload=data)
if done: if done:
break break
def createbytesresponseframesfrombytes(stream, requestid, data, def createcommandresponseframesfrombytes(stream, requestid, data,
maxframesize=DEFAULT_MAX_FRAME_SIZE): maxframesize=DEFAULT_MAX_FRAME_SIZE):
"""Create a raw frame to send a bytes response from static bytes input. """Create a raw frame to send a bytes response from static bytes input.
Returns a generator of bytearrays. Returns a generator of bytearrays.
""" """
# Simple case of a single frame. # Simple case of a single frame.
if len(data) <= maxframesize: if len(data) <= maxframesize:
flags = FLAG_BYTES_RESPONSE_EOS flags = FLAG_COMMAND_RESPONSE_EOS
yield stream.makeframe(requestid=requestid, yield stream.makeframe(requestid=requestid,
typeid=FRAME_TYPE_BYTES_RESPONSE, typeid=FRAME_TYPE_COMMAND_RESPONSE,
flags=flags, flags=flags,
payload=data) payload=data)
return return
offset = 0 offset = 0
while True: while True:
chunk = data[offset:offset + maxframesize] chunk = data[offset:offset + maxframesize]
offset += len(chunk) offset += len(chunk)
done = offset == len(data) done = offset == len(data)
if done: if done:
flags = FLAG_BYTES_RESPONSE_EOS flags = FLAG_COMMAND_RESPONSE_EOS
else: else:
flags = FLAG_BYTES_RESPONSE_CONTINUATION flags = FLAG_COMMAND_RESPONSE_CONTINUATION
yield stream.makeframe(requestid=requestid, yield stream.makeframe(requestid=requestid,
typeid=FRAME_TYPE_BYTES_RESPONSE, typeid=FRAME_TYPE_COMMAND_RESPONSE,
flags=flags, flags=flags,
payload=chunk) payload=chunk)
if done: if done:
break break
def createerrorframe(stream, requestid, msg, protocol=False, application=False): def createerrorframe(stream, requestid, msg, protocol=False, application=False):
# TODO properly handle frame size limits. # TODO properly handle frame size limits.
} }
meth = handlers.get(self._state) meth = handlers.get(self._state)
if not meth: if not meth:
raise error.ProgrammingError('unhandled state: %s' % self._state) raise error.ProgrammingError('unhandled state: %s' % self._state)
return meth(frame) return meth(frame)
def onbytesresponseready(self, stream, requestid, data): def oncommandresponseready(self, stream, requestid, data):
"""Signal that a bytes response is ready to be sent to the client. """Signal that a bytes response is ready to be sent to the client.
The raw bytes response is passed as an argument. The raw bytes response is passed as an argument.
""" """
ensureserverstream(stream) ensureserverstream(stream)
def sendframes(): def sendframes():
for frame in createbytesresponseframesfrombytes(stream, requestid, for frame in createcommandresponseframesfrombytes(stream, requestid,
data): data):
yield frame yield frame
self._activecommands.remove(requestid) self._activecommands.remove(requestid)
result = sendframes() result = sendframes()
if self._deferoutput: if self._deferoutput:
self._bufferedframegens.append(result) self._bufferedframegens.append(result)
'message': (_('received frame for inactive request ID: %d') % 'message': (_('received frame for inactive request ID: %d') %
frame.requestid), frame.requestid),
} }
request = self._activerequests[frame.requestid] request = self._activerequests[frame.requestid]
request.state = 'receiving' request.state = 'receiving'
handlers = { handlers = {
FRAME_TYPE_BYTES_RESPONSE: self._onbytesresponseframe, FRAME_TYPE_COMMAND_RESPONSE: self._oncommandresponseframe,
} }
meth = handlers.get(frame.typeid) meth = handlers.get(frame.typeid)
if not meth: if not meth:
raise error.ProgrammingError('unhandled frame type: %d' % raise error.ProgrammingError('unhandled frame type: %d' %
frame.typeid) frame.typeid)
return meth(request, frame) return meth(request, frame)
def _onbytesresponseframe(self, request, frame): def _oncommandresponseframe(self, request, frame):
if frame.flags & FLAG_BYTES_RESPONSE_EOS: if frame.flags & FLAG_COMMAND_RESPONSE_EOS:
request.state = 'received' request.state = 'received'
del self._activerequests[request.requestid] del self._activerequests[request.requestid]
return 'responsedata', { return 'responsedata', {
'request': request, 'request': request,
'expectmore': frame.flags & FLAG_BYTES_RESPONSE_CONTINUATION, 'expectmore': frame.flags & FLAG_COMMAND_RESPONSE_CONTINUATION,
'eos': frame.flags & FLAG_BYTES_RESPONSE_EOS, 'eos': frame.flags & FLAG_COMMAND_RESPONSE_EOS,
'data': frame.payload, 'data': frame.payload,
} }

mercurial/wireprotov2server.py

return True return True
rsp = wireproto.dispatch(repo, proto, command['command']) rsp = wireproto.dispatch(repo, proto, command['command'])
res.status = b'200 OK' res.status = b'200 OK'
res.headers[b'Content-Type'] = FRAMINGTYPE res.headers[b'Content-Type'] = FRAMINGTYPE
if isinstance(rsp, wireprototypes.bytesresponse): if isinstance(rsp, wireprototypes.bytesresponse):
action, meta = reactor.onbytesresponseready(outstream, action, meta = reactor.oncommandresponseready(outstream,
command['requestid'], command['requestid'],
rsp.data) rsp.data)
elif isinstance(rsp, wireprototypes.cborresponse): elif isinstance(rsp, wireprototypes.cborresponse):
encoded = cbor.dumps(rsp.value, canonical=True) encoded = cbor.dumps(rsp.value, canonical=True)
action, meta = reactor.onbytesresponseready(outstream, action, meta = reactor.oncommandresponseready(outstream,
command['requestid'], command['requestid'],
encoded) encoded)
else: else:
action, meta = reactor.onapplicationerror( action, meta = reactor.onapplicationerror(
_('unhandled response type from wire proto command')) _('unhandled response type from wire proto command'))
if action == 'sendframes': if action == 'sendframes':
res.setbodygen(meta['framegen']) res.setbodygen(meta['framegen'])
return True return True
elif action == 'noop': elif action == 'noop':

tests/test-http-api-httpv2.t

s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> 27\r\n s> 27\r\n
s> \x1f\x00\x00\x01\x00\x02\x01BX\x1dcustomreadonly bytes response s> \x1f\x00\x00\x01\x00\x02\x012X\x1dcustomreadonly bytes response
s> \r\n s> \r\n
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
$ sendhttpv2peer << EOF $ sendhttpv2peer << EOF
> command customreadonly > command customreadonly
> EOF > EOF
creating http peer for wire protocol version 2 creating http peer for wire protocol version 2
s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> 27\r\n s> 27\r\n
s> \x1f\x00\x00\x01\x00\x02\x01B s> \x1f\x00\x00\x01\x00\x02\x012
s> X\x1dcustomreadonly bytes response s> X\x1dcustomreadonly bytes response
s> \r\n s> \r\n
received frame(size=31; request=1; stream=2; streamflags=stream-begin; type=bytes-response; flags=eos) received frame(size=31; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
response: [b'customreadonly bytes response'] response: [b'customreadonly bytes response']
Request to read-write command fails because server is read-only by default Request to read-write command fails because server is read-only by default
GET to read-write request yields 405 GET to read-write request yields 405
s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> 27\r\n s> 27\r\n
s> \x1f\x00\x00\x01\x00\x02\x01BX\x1dcustomreadonly bytes response s> \x1f\x00\x00\x01\x00\x02\x012X\x1dcustomreadonly bytes response
s> \r\n s> \r\n
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
Authorized request for unknown command is rejected Authorized request for unknown command is rejected
$ sendhttpraw << EOF $ sendhttpraw << EOF
> httprequest POST api/$HTTPV2/rw/badcommand > httprequest POST api/$HTTPV2/rw/badcommand
s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> 27\r\n s> 27\r\n
s> \x1f\x00\x00\x01\x00\x02\x01BX\x1dcustomreadonly bytes response s> \x1f\x00\x00\x01\x00\x02\x012X\x1dcustomreadonly bytes response
s> \r\n s> \r\n
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
Multiple requests to "multirequest" URL are allowed Multiple requests to "multirequest" URL are allowed
$ sendhttpraw << EOF $ sendhttpraw << EOF
> httprequest POST api/$HTTPV2/ro/multirequest > httprequest POST api/$HTTPV2/ro/multirequest
s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> 27\r\n s> 27\r\n
s> \x1f\x00\x00\x01\x00\x02\x01BX\x1dcustomreadonly bytes response s> \x1f\x00\x00\x01\x00\x02\x012X\x1dcustomreadonly bytes response
s> \r\n s> \r\n
s> 27\r\n s> 27\r\n
s> \x1f\x00\x00\x03\x00\x02\x00BX\x1dcustomreadonly bytes response s> \x1f\x00\x00\x03\x00\x02\x002X\x1dcustomreadonly bytes response
s> \r\n s> \r\n
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
Interleaved requests to "multirequest" are processed Interleaved requests to "multirequest" are processed
$ sendhttpraw << EOF $ sendhttpraw << EOF
> httprequest POST api/$HTTPV2/ro/multirequest > httprequest POST api/$HTTPV2/ro/multirequest
s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> 28\r\n s> 28\r\n
s> \x00\x00\x03\x00\x02\x01B\xa3Fphases@Ibookmarks@Jnamespaces@ s> \x00\x00\x03\x00\x02\x012\xa3Fphases@Ibookmarks@Jnamespaces@
s> \r\n s> \r\n
s> 9\r\n s> 9\r\n
s> \x01\x00\x00\x01\x00\x02\x00B\xa0 s> \x01\x00\x00\x01\x00\x02\x002\xa0
s> \r\n s> \r\n
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
Restart server to disable read-write access Restart server to disable read-write access
$ killdaemons.py $ killdaemons.py
$ cat > server/.hg/hgrc << EOF $ cat > server/.hg/hgrc << EOF

tests/test-http-protocol.t

s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> 1e\r\n s> 1e\r\n
s> \x16\x00\x00\x01\x00\x02\x01B s> \x16\x00\x00\x01\x00\x02\x012
s> \x81T\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00 s> \x81T\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00
s> \r\n s> \r\n
received frame(size=22; request=1; stream=2; streamflags=stream-begin; type=bytes-response; flags=eos) received frame(size=22; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
response: [b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'] response: [b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00']
$ killdaemons.py $ killdaemons.py

tests/test-wireproto-clientreactor.py

request, action, meta = reactor.callcommand(b'foo', {}) request, action, meta = reactor.callcommand(b'foo', {})
self.assertEqual(action, b'sendframes') self.assertEqual(action, b'sendframes')
for f in meta[b'framegen']: for f in meta[b'framegen']:
pass pass
action, meta = sendframe( action, meta = sendframe(
reactor, reactor,
ffs(b'%d 0 stream-begin 4 0 foo' % request.requestid)) ffs(b'%d 0 stream-begin command-response 0 foo' %
request.requestid))
self.assertEqual(action, b'responsedata') self.assertEqual(action, b'responsedata')
action, meta = sendframe( action, meta = sendframe(
reactor, reactor,
ffs(b'%d 0 0 4 eos bar' % request.requestid)) ffs(b'%d 0 0 command-response eos bar' % request.requestid))
self.assertEqual(action, b'responsedata') self.assertEqual(action, b'responsedata')
if __name__ == '__main__': if __name__ == '__main__':
import silenttestrunner import silenttestrunner
silenttestrunner.main(__name__) silenttestrunner.main(__name__)

tests/test-wireproto-command-branchmap.t

s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> 78\r\n s> 78\r\n
s> p\x00\x00\x01\x00\x02\x01B s> p\x00\x00\x01\x00\x02\x012
s> \xa3Gbranch1\x81T\xb5\xfa\xac\xdf\xd2c7h\xcb1R3l\xc0\x953\x81&f\x88Gbranch2\x81T"Aa\xc7X\x9a\xa4\x8f\xa8:H\xfe\xff^\x95\xb5j\xe3\'\xfcGdefault\x82T&\x80Z\xba\x1e`\n s> \xa3Gbranch1\x81T\xb5\xfa\xac\xdf\xd2c7h\xcb1R3l\xc0\x953\x81&f\x88Gbranch2\x81T"Aa\xc7X\x9a\xa4\x8f\xa8:H\xfe\xff^\x95\xb5j\xe3\'\xfcGdefault\x82T&\x80Z\xba\x1e`\n
s> \x82\xe96a\x14\x9f#\x13\x86j"\x1a{T\xbe\x0e\xf7<\x17\xad\xe3\xfc\x89\xdcAp\x1e\xb9\xfc:\x91\xb5\x82\x82 s> \x82\xe96a\x14\x9f#\x13\x86j"\x1a{T\xbe\x0e\xf7<\x17\xad\xe3\xfc\x89\xdcAp\x1e\xb9\xfc:\x91\xb5\x82\x82
s> \r\n s> \r\n
received frame(size=112; request=1; stream=2; streamflags=stream-begin; type=bytes-response; flags=eos) received frame(size=112; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
response: {b'branch1': [b'\xb5\xfa\xac\xdf\xd2c7h\xcb1R3l\xc0\x953\x81&f\x88'], b'branch2': [b'"Aa\xc7X\x9a\xa4\x8f\xa8:H\xfe\xff^\x95\xb5j\xe3\'\xfc'], b'default': [b'&\x80Z\xba\x1e`\n\x82\xe96a\x14\x9f#\x13\x86j"\x1a{', b'\xbe\x0e\xf7<\x17\xad\xe3\xfc\x89\xdcAp\x1e\xb9\xfc:\x91\xb5\x82\x82']} response: {b'branch1': [b'\xb5\xfa\xac\xdf\xd2c7h\xcb1R3l\xc0\x953\x81&f\x88'], b'branch2': [b'"Aa\xc7X\x9a\xa4\x8f\xa8:H\xfe\xff^\x95\xb5j\xe3\'\xfc'], b'default': [b'&\x80Z\xba\x1e`\n\x82\xe96a\x14\x9f#\x13\x86j"\x1a{', b'\xbe\x0e\xf7<\x17\xad\xe3\xfc\x89\xdcAp\x1e\xb9\xfc:\x91\xb5\x82\x82']}
$ cat error.log $ cat error.log

tests/test-wireproto-command-capabilities.t

s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> 1d7\r\n s> 1d7\r\n
s> \xcf\x01\x00\x01\x00\x02\x01B s> \xcf\x01\x00\x01\x00\x02\x012
s> \xa4Hcommands\xa7Eheads\xa2Dargs\xa1Jpubliconly\xf4Kpermissions\x81DpullEknown\xa2Dargs\xa1Enodes\x81HdeadbeefKpermissions\x81DpullFlookup\xa2Dargs\xa1CkeyCfooKpermissions\x81DpullGpushkey\xa2Dargs\xa4CkeyCkeyCnewCnewColdColdInamespaceBnsKpermissions\x81DpushHlistkeys\xa2Dargs\xa1InamespaceBnsKpermissions\x81DpullIbranchmap\xa2Dargs\xa0Kpermissions\x81DpullLcapabilities\xa2Dargs\xa0Kpermissions\x81DpullKcompression\x82\xa1DnameDzstd\xa1DnameDzlibNrawrepoformats\x82LgeneraldeltaHrevlogv1Qframingmediatypes\x81X&application/mercurial-exp-framing-0004 s> \xa4Hcommands\xa7Eheads\xa2Dargs\xa1Jpubliconly\xf4Kpermissions\x81DpullEknown\xa2Dargs\xa1Enodes\x81HdeadbeefKpermissions\x81DpullFlookup\xa2Dargs\xa1CkeyCfooKpermissions\x81DpullGpushkey\xa2Dargs\xa4CkeyCkeyCnewCnewColdColdInamespaceBnsKpermissions\x81DpushHlistkeys\xa2Dargs\xa1InamespaceBnsKpermissions\x81DpullIbranchmap\xa2Dargs\xa0Kpermissions\x81DpullLcapabilities\xa2Dargs\xa0Kpermissions\x81DpullKcompression\x82\xa1DnameDzstd\xa1DnameDzlibNrawrepoformats\x82LgeneraldeltaHrevlogv1Qframingmediatypes\x81X&application/mercurial-exp-framing-0004
s> \r\n s> \r\n
received frame(size=463; request=1; stream=2; streamflags=stream-begin; type=bytes-response; flags=eos) received frame(size=463; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
response: [{b'commands': {b'branchmap': {b'args': {}, b'permissions': [b'pull']}, b'capabilities': {b'args': {}, b'permissions': [b'pull']}, b'heads': {b'args': {b'publiconly': False}, b'permissions': [b'pull']}, b'known': {b'args': {b'nodes': [b'deadbeef']}, b'permissions': [b'pull']}, b'listkeys': {b'args': {b'namespace': b'ns'}, b'permissions': [b'pull']}, b'lookup': {b'args': {b'key': b'foo'}, b'permissions': [b'pull']}, b'pushkey': {b'args': {b'key': b'key', b'namespace': b'ns', b'new': b'new', b'old': b'old'}, b'permissions': [b'push']}}, b'compression': [{b'name': b'zstd'}, {b'name': b'zlib'}], b'framingmediatypes': [b'application/mercurial-exp-framing-0004'], b'rawrepoformats': [b'generaldelta', b'revlogv1']}] response: [{b'commands': {b'branchmap': {b'args': {}, b'permissions': [b'pull']}, b'capabilities': {b'args': {}, b'permissions': [b'pull']}, b'heads': {b'args': {b'publiconly': False}, b'permissions': [b'pull']}, b'known': {b'args': {b'nodes': [b'deadbeef']}, b'permissions': [b'pull']}, b'listkeys': {b'args': {b'namespace': b'ns'}, b'permissions': [b'pull']}, b'lookup': {b'args': {b'key': b'foo'}, b'permissions': [b'pull']}, b'pushkey': {b'args': {b'key': b'key', b'namespace': b'ns', b'new': b'new', b'old': b'old'}, b'permissions': [b'push']}}, b'compression': [{b'name': b'zstd'}, {b'name': b'zlib'}], b'framingmediatypes': [b'application/mercurial-exp-framing-0004'], b'rawrepoformats': [b'generaldelta', b'revlogv1']}]
$ cat error.log $ cat error.log

tests/test-wireproto-command-heads.t

s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> 48\r\n s> 48\r\n
s> @\x00\x00\x01\x00\x02\x01B s> @\x00\x00\x01\x00\x02\x012
s> \x83T\x1dok\x91\xd4J\xab\xa6\xd5\xe5\x80\xbc0\xa9\x94\x850\xdb\xe0\x0bT\xaeI.6\xb0\xc83\x9f\xfa\xf3(\xd0\x0b\x85\xb4R]\xe1\x16^T)Dm-\xc5A\x9c_\x97Dz\x8b\xc0b\xe4\xcc2\x8b\xf2A s> \x83T\x1dok\x91\xd4J\xab\xa6\xd5\xe5\x80\xbc0\xa9\x94\x850\xdb\xe0\x0bT\xaeI.6\xb0\xc83\x9f\xfa\xf3(\xd0\x0b\x85\xb4R]\xe1\x16^T)Dm-\xc5A\x9c_\x97Dz\x8b\xc0b\xe4\xcc2\x8b\xf2A
s> \r\n s> \r\n
received frame(size=64; request=1; stream=2; streamflags=stream-begin; type=bytes-response; flags=eos) received frame(size=64; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
response: [b'\x1dok\x91\xd4J\xab\xa6\xd5\xe5\x80\xbc0\xa9\x94\x850\xdb\xe0\x0b', b'\xaeI.6\xb0\xc83\x9f\xfa\xf3(\xd0\x0b\x85\xb4R]\xe1\x16^', b')Dm-\xc5A\x9c_\x97Dz\x8b\xc0b\xe4\xcc2\x8b\xf2A'] response: [b'\x1dok\x91\xd4J\xab\xa6\xd5\xe5\x80\xbc0\xa9\x94\x850\xdb\xe0\x0b', b'\xaeI.6\xb0\xc83\x9f\xfa\xf3(\xd0\x0b\x85\xb4R]\xe1\x16^', b')Dm-\xc5A\x9c_\x97Dz\x8b\xc0b\xe4\xcc2\x8b\xf2A']
Requesting just the public heads works Requesting just the public heads works
$ sendhttpv2peer << EOF $ sendhttpv2peer << EOF
> command heads > command heads
s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> 1e\r\n s> 1e\r\n
s> \x16\x00\x00\x01\x00\x02\x01B s> \x16\x00\x00\x01\x00\x02\x012
s> \x81Tx\xd2\xdc\xa46\xb2\xf5\xb1\x88\xac&~)\xb8\x1e\x07&m8\xfc s> \x81Tx\xd2\xdc\xa46\xb2\xf5\xb1\x88\xac&~)\xb8\x1e\x07&m8\xfc
s> \r\n s> \r\n
received frame(size=22; request=1; stream=2; streamflags=stream-begin; type=bytes-response; flags=eos) received frame(size=22; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
response: [b'x\xd2\xdc\xa46\xb2\xf5\xb1\x88\xac&~)\xb8\x1e\x07&m8\xfc'] response: [b'x\xd2\xdc\xa46\xb2\xf5\xb1\x88\xac&~)\xb8\x1e\x07&m8\xfc']
$ cat error.log $ cat error.log

tests/test-wireproto-command-known.t

s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> 9\r\n s> 9\r\n
s> \x01\x00\x00\x01\x00\x02\x01B s> \x01\x00\x00\x01\x00\x02\x012
s> @ s> @
s> \r\n s> \r\n
received frame(size=1; request=1; stream=2; streamflags=stream-begin; type=bytes-response; flags=eos) received frame(size=1; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
response: [] response: []
Single known node works Single known node works
$ sendhttpv2peer << EOF $ sendhttpv2peer << EOF
> command known > command known
s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> a\r\n s> a\r\n
s> \x02\x00\x00\x01\x00\x02\x01B s> \x02\x00\x00\x01\x00\x02\x012
s> A1 s> A1
s> \r\n s> \r\n
received frame(size=2; request=1; stream=2; streamflags=stream-begin; type=bytes-response; flags=eos) received frame(size=2; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
response: [True] response: [True]
Multiple nodes works Multiple nodes works
$ sendhttpv2peer << EOF $ sendhttpv2peer << EOF
> command known > command known
s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> c\r\n s> c\r\n
s> \x04\x00\x00\x01\x00\x02\x01B s> \x04\x00\x00\x01\x00\x02\x012
s> C101 s> C101
s> \r\n s> \r\n
received frame(size=4; request=1; stream=2; streamflags=stream-begin; type=bytes-response; flags=eos) received frame(size=4; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
response: [True, False, True] response: [True, False, True]
$ cat error.log $ cat error.log

tests/test-wireproto-command-listkeys.t

s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> 28\r\n s> 28\r\n
s> \x00\x00\x01\x00\x02\x01B s> \x00\x00\x01\x00\x02\x012
s> \xa3Fphases@Ibookmarks@Jnamespaces@ s> \xa3Fphases@Ibookmarks@Jnamespaces@
s> \r\n s> \r\n
received frame(size=32; request=1; stream=2; streamflags=stream-begin; type=bytes-response; flags=eos) received frame(size=32; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
response: {b'bookmarks': b'', b'namespaces': b'', b'phases': b''} response: {b'bookmarks': b'', b'namespaces': b'', b'phases': b''}
Request for phases works Request for phases works
$ sendhttpv2peer << EOF $ sendhttpv2peer << EOF
> command listkeys > command listkeys
s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> 45\r\n s> 45\r\n
s> =\x00\x00\x01\x00\x02\x01B s> =\x00\x00\x01\x00\x02\x012
s> \xa2JpublishingDTrueX(be0ef73c17ade3fc89dc41701eb9fc3a91b58282A1 s> \xa2JpublishingDTrueX(be0ef73c17ade3fc89dc41701eb9fc3a91b58282A1
s> \r\n s> \r\n
received frame(size=61; request=1; stream=2; streamflags=stream-begin; type=bytes-response; flags=eos) received frame(size=61; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
response: {b'be0ef73c17ade3fc89dc41701eb9fc3a91b58282': b'1', b'publishing': b'True'} response: {b'be0ef73c17ade3fc89dc41701eb9fc3a91b58282': b'1', b'publishing': b'True'}
Request for bookmarks works Request for bookmarks works
$ sendhttpv2peer << EOF $ sendhttpv2peer << EOF
> command listkeys > command listkeys
s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> 35\r\n s> 35\r\n
s> -\x00\x00\x01\x00\x02\x01B s> -\x00\x00\x01\x00\x02\x012
s> \xa1A@X(26805aba1e600a82e93661149f2313866a221a7b s> \xa1A@X(26805aba1e600a82e93661149f2313866a221a7b
s> \r\n s> \r\n
received frame(size=45; request=1; stream=2; streamflags=stream-begin; type=bytes-response; flags=eos) received frame(size=45; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
response: {b'@': b'26805aba1e600a82e93661149f2313866a221a7b'} response: {b'@': b'26805aba1e600a82e93661149f2313866a221a7b'}
$ cat error.log $ cat error.log

tests/test-wireproto-command-lookup.t

s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> 1d\r\n s> 1d\r\n
s> \x15\x00\x00\x01\x00\x02\x01B s> \x15\x00\x00\x01\x00\x02\x012
s> TBk\xad\xa5\xc6u\x98\xcae\x03mW\xd9\xe4\xb6K\x0c\x1c\xe7\xa0 s> TBk\xad\xa5\xc6u\x98\xcae\x03mW\xd9\xe4\xb6K\x0c\x1c\xe7\xa0
s> \r\n s> \r\n
received frame(size=21; request=1; stream=2; streamflags=stream-begin; type=bytes-response; flags=eos) received frame(size=21; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
response: b'Bk\xad\xa5\xc6u\x98\xcae\x03mW\xd9\xe4\xb6K\x0c\x1c\xe7\xa0' response: b'Bk\xad\xa5\xc6u\x98\xcae\x03mW\xd9\xe4\xb6K\x0c\x1c\xe7\xa0'
$ cat error.log $ cat error.log

tests/test-wireproto-command-pushkey.t

s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> 9\r\n s> 9\r\n
s> \x01\x00\x00\x01\x00\x02\x01B s> \x01\x00\x00\x01\x00\x02\x012
s> \xf5 s> \xf5
s> \r\n s> \r\n
received frame(size=1; request=1; stream=2; streamflags=stream-begin; type=bytes-response; flags=eos) received frame(size=1; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
response: True response: True
$ sendhttpv2peer << EOF $ sendhttpv2peer << EOF
> command listkeys > command listkeys
> namespace bookmarks > namespace bookmarks
> EOF > EOF
s> makefile('rb', None) s> makefile('rb', None)
s> HTTP/1.1 200 OK\r\n s> HTTP/1.1 200 OK\r\n
s> Server: testing stub value\r\n s> Server: testing stub value\r\n
s> Date: $HTTP_DATE$\r\n s> Date: $HTTP_DATE$\r\n
s> Content-Type: application/mercurial-exp-framing-0004\r\n s> Content-Type: application/mercurial-exp-framing-0004\r\n
s> Transfer-Encoding: chunked\r\n s> Transfer-Encoding: chunked\r\n
s> \r\n s> \r\n
s> 35\r\n s> 35\r\n
s> -\x00\x00\x01\x00\x02\x01B s> -\x00\x00\x01\x00\x02\x012
s> \xa1A@X(426bada5c67598ca65036d57d9e4b64b0c1ce7a0 s> \xa1A@X(426bada5c67598ca65036d57d9e4b64b0c1ce7a0
s> \r\n s> \r\n
received frame(size=45; request=1; stream=2; streamflags=stream-begin; type=bytes-response; flags=eos) received frame(size=45; request=1; stream=2; streamflags=stream-begin; type=command-response; flags=eos)
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
response: {b'@': b'426bada5c67598ca65036d57d9e4b64b0c1ce7a0'} response: {b'@': b'426bada5c67598ca65036d57d9e4b64b0c1ce7a0'}
$ cat error.log $ cat error.log

tests/test-wireproto-serverreactor.py

def testconflictingrequestidallowed(self): def testconflictingrequestidallowed(self):
"""Multiple fully serviced commands with same request ID is allowed.""" """Multiple fully serviced commands with same request ID is allowed."""
reactor = makereactor() reactor = makereactor()
results = [] results = []
outstream = reactor.makeoutputstream() outstream = reactor.makeoutputstream()
results.append(self._sendsingleframe( results.append(self._sendsingleframe(
reactor, ffs(b'1 1 stream-begin command-request new ' reactor, ffs(b'1 1 stream-begin command-request new '
b"cbor:{b'name': b'command'}"))) b"cbor:{b'name': b'command'}")))
result = reactor.onbytesresponseready(outstream, 1, b'response1') result = reactor.oncommandresponseready(outstream, 1, b'response1')
self.assertaction(result, b'sendframes') self.assertaction(result, b'sendframes')
list(result[1][b'framegen']) list(result[1][b'framegen'])
results.append(self._sendsingleframe( results.append(self._sendsingleframe(
reactor, ffs(b'1 1 stream-begin command-request new ' reactor, ffs(b'1 1 stream-begin command-request new '
b"cbor:{b'name': b'command'}"))) b"cbor:{b'name': b'command'}")))
result = reactor.onbytesresponseready(outstream, 1, b'response2') result = reactor.oncommandresponseready(outstream, 1, b'response2')
self.assertaction(result, b'sendframes') self.assertaction(result, b'sendframes')
list(result[1][b'framegen']) list(result[1][b'framegen'])
results.append(self._sendsingleframe( results.append(self._sendsingleframe(
reactor, ffs(b'1 1 stream-begin command-request new ' reactor, ffs(b'1 1 stream-begin command-request new '
b"cbor:{b'name': b'command'}"))) b"cbor:{b'name': b'command'}")))
result = reactor.onbytesresponseready(outstream, 1, b'response3') result = reactor.oncommandresponseready(outstream, 1, b'response3')
self.assertaction(result, b'sendframes') self.assertaction(result, b'sendframes')
list(result[1][b'framegen']) list(result[1][b'framegen'])
for i in range(3): for i in range(3):
self.assertaction(results[i], b'runcommand') self.assertaction(results[i], b'runcommand')
self.assertEqual(results[i][1], { self.assertEqual(results[i][1], {
b'requestid': 1, b'requestid': 1,
b'command': b'command', b'command': b'command',
def testsimpleresponse(self): def testsimpleresponse(self):
"""Bytes response to command sends result frames.""" """Bytes response to command sends result frames."""
reactor = makereactor() reactor = makereactor()
instream = framing.stream(1) instream = framing.stream(1)
list(sendcommandframes(reactor, instream, 1, b'mycommand', {})) list(sendcommandframes(reactor, instream, 1, b'mycommand', {}))
outstream = reactor.makeoutputstream() outstream = reactor.makeoutputstream()
result = reactor.onbytesresponseready(outstream, 1, b'response') result = reactor.oncommandresponseready(outstream, 1, b'response')
self.assertaction(result, b'sendframes') self.assertaction(result, b'sendframes')
self.assertframesequal(result[1][b'framegen'], [ self.assertframesequal(result[1][b'framegen'], [
b'1 2 stream-begin bytes-response eos response', b'1 2 stream-begin command-response eos response',
]) ])
def testmultiframeresponse(self): def testmultiframeresponse(self):
"""Bytes response spanning multiple frames is handled.""" """Bytes response spanning multiple frames is handled."""
first = b'x' * framing.DEFAULT_MAX_FRAME_SIZE first = b'x' * framing.DEFAULT_MAX_FRAME_SIZE
second = b'y' * 100 second = b'y' * 100
reactor = makereactor() reactor = makereactor()
instream = framing.stream(1) instream = framing.stream(1)
list(sendcommandframes(reactor, instream, 1, b'mycommand', {})) list(sendcommandframes(reactor, instream, 1, b'mycommand', {}))
outstream = reactor.makeoutputstream() outstream = reactor.makeoutputstream()
result = reactor.onbytesresponseready(outstream, 1, first + second) result = reactor.oncommandresponseready(outstream, 1, first + second)
self.assertaction(result, b'sendframes') self.assertaction(result, b'sendframes')
self.assertframesequal(result[1][b'framegen'], [ self.assertframesequal(result[1][b'framegen'], [
b'1 2 stream-begin bytes-response continuation %s' % first, b'1 2 stream-begin command-response continuation %s' % first,
b'1 2 0 bytes-response eos %s' % second, b'1 2 0 command-response eos %s' % second,
]) ])
def testapplicationerror(self): def testapplicationerror(self):
reactor = makereactor() reactor = makereactor()
instream = framing.stream(1) instream = framing.stream(1)
list(sendcommandframes(reactor, instream, 1, b'mycommand', {})) list(sendcommandframes(reactor, instream, 1, b'mycommand', {}))
outstream = reactor.makeoutputstream() outstream = reactor.makeoutputstream()
result = reactor.onapplicationerror(outstream, 1, b'some message') result = reactor.onapplicationerror(outstream, 1, b'some message')
self.assertaction(result, b'sendframes') self.assertaction(result, b'sendframes')
self.assertframesequal(result[1][b'framegen'], [ self.assertframesequal(result[1][b'framegen'], [
b'1 2 stream-begin error-response application some message', b'1 2 stream-begin error-response application some message',
]) ])
def test1commanddeferresponse(self): def test1commanddeferresponse(self):
"""Responses when in deferred output mode are delayed until EOF.""" """Responses when in deferred output mode are delayed until EOF."""
reactor = makereactor(deferoutput=True) reactor = makereactor(deferoutput=True)
instream = framing.stream(1) instream = framing.stream(1)
results = list(sendcommandframes(reactor, instream, 1, b'mycommand', results = list(sendcommandframes(reactor, instream, 1, b'mycommand',
{})) {}))
self.assertEqual(len(results), 1) self.assertEqual(len(results), 1)
self.assertaction(results[0], b'runcommand') self.assertaction(results[0], b'runcommand')
outstream = reactor.makeoutputstream() outstream = reactor.makeoutputstream()
result = reactor.onbytesresponseready(outstream, 1, b'response') result = reactor.oncommandresponseready(outstream, 1, b'response')
self.assertaction(result, b'noop') self.assertaction(result, b'noop')
result = reactor.oninputeof() result = reactor.oninputeof()
self.assertaction(result, b'sendframes') self.assertaction(result, b'sendframes')
self.assertframesequal(result[1][b'framegen'], [ self.assertframesequal(result[1][b'framegen'], [
b'1 2 stream-begin bytes-response eos response', b'1 2 stream-begin command-response eos response',
]) ])
def testmultiplecommanddeferresponse(self): def testmultiplecommanddeferresponse(self):
reactor = makereactor(deferoutput=True) reactor = makereactor(deferoutput=True)
instream = framing.stream(1) instream = framing.stream(1)
list(sendcommandframes(reactor, instream, 1, b'command1', {})) list(sendcommandframes(reactor, instream, 1, b'command1', {}))
list(sendcommandframes(reactor, instream, 3, b'command2', {})) list(sendcommandframes(reactor, instream, 3, b'command2', {}))
outstream = reactor.makeoutputstream() outstream = reactor.makeoutputstream()
result = reactor.onbytesresponseready(outstream, 1, b'response1') result = reactor.oncommandresponseready(outstream, 1, b'response1')
self.assertaction(result, b'noop') self.assertaction(result, b'noop')
result = reactor.onbytesresponseready(outstream, 3, b'response2') result = reactor.oncommandresponseready(outstream, 3, b'response2')
self.assertaction(result, b'noop') self.assertaction(result, b'noop')
result = reactor.oninputeof() result = reactor.oninputeof()
self.assertaction(result, b'sendframes') self.assertaction(result, b'sendframes')
self.assertframesequal(result[1][b'framegen'], [ self.assertframesequal(result[1][b'framegen'], [
b'1 2 stream-begin bytes-response eos response1', b'1 2 stream-begin command-response eos response1',
b'3 2 0 bytes-response eos response2' b'3 2 0 command-response eos response2'
]) ])
def testrequestidtracking(self): def testrequestidtracking(self):
reactor = makereactor(deferoutput=True) reactor = makereactor(deferoutput=True)
instream = framing.stream(1) instream = framing.stream(1)
list(sendcommandframes(reactor, instream, 1, b'command1', {})) list(sendcommandframes(reactor, instream, 1, b'command1', {}))
list(sendcommandframes(reactor, instream, 3, b'command2', {})) list(sendcommandframes(reactor, instream, 3, b'command2', {}))
list(sendcommandframes(reactor, instream, 5, b'command3', {})) list(sendcommandframes(reactor, instream, 5, b'command3', {}))
# Register results for commands out of order. # Register results for commands out of order.
outstream = reactor.makeoutputstream() outstream = reactor.makeoutputstream()
reactor.onbytesresponseready(outstream, 3, b'response3') reactor.oncommandresponseready(outstream, 3, b'response3')
reactor.onbytesresponseready(outstream, 1, b'response1') reactor.oncommandresponseready(outstream, 1, b'response1')
reactor.onbytesresponseready(outstream, 5, b'response5') reactor.oncommandresponseready(outstream, 5, b'response5')
result = reactor.oninputeof() result = reactor.oninputeof()
self.assertaction(result, b'sendframes') self.assertaction(result, b'sendframes')
self.assertframesequal(result[1][b'framegen'], [ self.assertframesequal(result[1][b'framegen'], [
b'3 2 stream-begin bytes-response eos response3', b'3 2 stream-begin command-response eos response3',
b'1 2 0 bytes-response eos response1', b'1 2 0 command-response eos response1',
b'5 2 0 bytes-response eos response5', b'5 2 0 command-response eos response5',
]) ])
def testduplicaterequestonactivecommand(self): def testduplicaterequestonactivecommand(self):
"""Receiving a request ID that matches a request that isn't finished.""" """Receiving a request ID that matches a request that isn't finished."""
reactor = makereactor() reactor = makereactor()
stream = framing.stream(1) stream = framing.stream(1)
list(sendcommandframes(reactor, stream, 1, b'command1', {})) list(sendcommandframes(reactor, stream, 1, b'command1', {}))
results = list(sendcommandframes(reactor, stream, 1, b'command1', {})) results = list(sendcommandframes(reactor, stream, 1, b'command1', {}))
self.assertaction(results[0], b'error') self.assertaction(results[0], b'error')
self.assertEqual(results[0][1], { self.assertEqual(results[0][1], {
b'message': b'request with ID 1 is already active', b'message': b'request with ID 1 is already active',
}) })
def testduplicaterequestonactivecommandnosend(self): def testduplicaterequestonactivecommandnosend(self):
"""Same as above but we've registered a response but haven't sent it.""" """Same as above but we've registered a response but haven't sent it."""
reactor = makereactor() reactor = makereactor()
instream = framing.stream(1) instream = framing.stream(1)
list(sendcommandframes(reactor, instream, 1, b'command1', {})) list(sendcommandframes(reactor, instream, 1, b'command1', {}))
outstream = reactor.makeoutputstream() outstream = reactor.makeoutputstream()
reactor.onbytesresponseready(outstream, 1, b'response') reactor.oncommandresponseready(outstream, 1, b'response')
# We've registered the response but haven't sent it. From the # We've registered the response but haven't sent it. From the
# perspective of the reactor, the command is still active. # perspective of the reactor, the command is still active.
results = list(sendcommandframes(reactor, instream, 1, b'command1', {})) results = list(sendcommandframes(reactor, instream, 1, b'command1', {}))
self.assertaction(results[0], b'error') self.assertaction(results[0], b'error')
self.assertEqual(results[0][1], { self.assertEqual(results[0][1], {
b'message': b'request with ID 1 is already active', b'message': b'request with ID 1 is already active',
}) })
def testduplicaterequestaftersend(self): def testduplicaterequestaftersend(self):
"""We can use a duplicate request ID after we've sent the response.""" """We can use a duplicate request ID after we've sent the response."""
reactor = makereactor() reactor = makereactor()
instream = framing.stream(1) instream = framing.stream(1)
list(sendcommandframes(reactor, instream, 1, b'command1', {})) list(sendcommandframes(reactor, instream, 1, b'command1', {}))
outstream = reactor.makeoutputstream() outstream = reactor.makeoutputstream()
res = reactor.onbytesresponseready(outstream, 1, b'response') res = reactor.oncommandresponseready(outstream, 1, b'response')
list(res[1][b'framegen']) list(res[1][b'framegen'])
results = list(sendcommandframes(reactor, instream, 1, b'command1', {})) results = list(sendcommandframes(reactor, instream, 1, b'command1', {}))
self.assertaction(results[0], b'runcommand') self.assertaction(results[0], b'runcommand')
if __name__ == '__main__': if __name__ == '__main__':
import silenttestrunner import silenttestrunner
silenttestrunner.main(__name__) silenttestrunner.main(__name__)