This is an archive of the discontinued Mercurial Phabricator instance.

Differential D3379

wireprotov2: move response handling out of httppeer
ClosedPublic

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

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHGa656cba08a04: wireprotov2: move response handling out of httppeer
Summary

And fix some bugs while we're here.

The code for processing response data from the unified framing
protocol is mostly peer agnostic. The peer-specific bits are the
configuration of the client reactor and how I/O is performed. I
initially implemented things in httppeer for expediency.

This commit establishes a module for holding the peer API level
code for the framing based protocol. Inside this module we have
a class to help coordinate higher-level activities, such as managing
response object.

The client handler bits could be rolled into clientreactor. However,
I want clientreactor to be sans I/O and I want it to only be
concerned with protocol-level details, not higher-level concepts
like how protocol events are converted into peer API concepts. I
want clientreactor to receive a frame and then tell the caller what
should probably be done about it. If we start putting things like
future resolution into clientreactor, we'll constrain how the protocol
can be used (e.g. by requiring futures).

The new code is loosely based on what was in httppeer before. I
changed things a bit around response handling. We now buffer the
entire response "body" and then handle it as one atomic unit. This
fixed a bug around decoding CBOR data that spanned multiple frames.
I also fixed an off-by-one bug where we failed to read a single byte
CBOR value at the end of the stream. That's why tests have changed.

The new state of httppeer is much cleaner. It is largely agnostic
about framing protocol implementation details. That's how it should
be: the framing protocol is designed to be largely transport
agnostic. We want peers merely putting bytes on the wire and telling
the framing protocol where to read response data from.

There's still a bit of work to be done here, especially for
representing responses. But at least we're a step closer to having a
higher-level peer interface that can be plugged into the SSH peer
someday.

I initially added this class to wireprotoframing. However, we'll
eventually need version 2 specific functions to convert CBOR responses
into data structures expected by the code calling commands. This
needs to live somewhere. Since that code would be shared across peers,
we need a common module. We have wireprotov1peer for the equivalent
version 1 code. So I decided to establish wireprotov2peer.

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 rHGa656cba08a04: wireprotov2: move response handling out of httppeer (authored by indygreg). · Explain WhyApr 16 2018, 7:09 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 8322

mercurial/httppeer.py

# httppeer.py - HTTP repository proxy classes for mercurial # httppeer.py - HTTP repository proxy classes for mercurial
# #
# Copyright 2005, 2006 Matt Mackall <mpm@selenic.com> # Copyright 2005, 2006 Matt Mackall <mpm@selenic.com>
# Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com> # Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com>
# #
# 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 from __future__ import absolute_import
import errno import errno
import io import io
import os import os
import socket import socket
import struct import struct
import sys
import tempfile import tempfile
import weakref import weakref
from .i18n import _ from .i18n import _
from .thirdparty import ( from .thirdparty import (
cbor, cbor,
) )
from .thirdparty.zope import ( from .thirdparty.zope import (
interface as zi, interface as zi,
) )
from . import ( from . import (
bundle2, bundle2,
error, error,
httpconnection, httpconnection,
pycompat, pycompat,
repository, repository,
statichttprepo, statichttprepo,
url as urlmod, url as urlmod,
util, util,
wireprotoframing, wireprotoframing,
wireprototypes, wireprototypes,
wireprotov1peer, wireprotov1peer,
wireprotov2peer,
wireprotov2server, wireprotov2server,
) )
httplib = util.httplib httplib = util.httplib
urlerr = util.urlerr urlerr = util.urlerr
urlreq = util.urlreq urlreq = util.urlreq
def encodevalueinheaders(value, header, limit): def encodevalueinheaders(value, header, limit):
def _abort(self, exception): def _abort(self, exception):
raise exception raise exception
def sendv2request(ui, opener, requestbuilder, apiurl, permission, requests): def sendv2request(ui, opener, requestbuilder, apiurl, permission, requests):
reactor = wireprotoframing.clientreactor(hasmultiplesend=False, reactor = wireprotoframing.clientreactor(hasmultiplesend=False,
buffersends=True) buffersends=True)
handler = wireprotov2peer.clienthandler(ui, reactor)
url = '%s/%s' % (apiurl, permission) url = '%s/%s' % (apiurl, permission)
if len(requests) > 1: if len(requests) > 1:
url += '/multirequest' url += '/multirequest'
else: else:
url += '/%s' % requests[0][0] url += '/%s' % requests[0][0]
# Request ID to (request, future)
requestmap = {}
for command, args, f in requests: for command, args, f in requests:
request, action, meta = reactor.callcommand(command, args) assert not list(handler.callcommand(command, args, f))
assert action == 'noop'
requestmap[request.requestid] = (request, f)
action, meta = reactor.flushcommands()
assert action == 'sendframes'
# TODO stream this. # TODO stream this.
body = b''.join(map(bytes, meta['framegen'])) body = b''.join(map(bytes, handler.flushcommands()))
# TODO modify user-agent to reflect v2 # TODO modify user-agent to reflect v2
headers = { headers = {
r'Accept': wireprotov2server.FRAMINGTYPE, r'Accept': wireprotov2server.FRAMINGTYPE,
r'Content-Type': wireprotov2server.FRAMINGTYPE, r'Content-Type': wireprotov2server.FRAMINGTYPE,
} }
req = requestbuilder(pycompat.strurl(url), body, headers) req = requestbuilder(pycompat.strurl(url), body, headers)
req.add_unredirected_header(r'Content-Length', r'%d' % len(body)) req.add_unredirected_header(r'Content-Length', r'%d' % len(body))
try: try:
res = opener.open(req) res = opener.open(req)
except urlerr.httperror as e: except urlerr.httperror as e:
if e.code == 401: if e.code == 401:
raise error.Abort(_('authorization failed')) raise error.Abort(_('authorization failed'))
raise raise
except httplib.HTTPException as e: except httplib.HTTPException as e:
ui.traceback() ui.traceback()
raise IOError(None, e) raise IOError(None, e)
return reactor, requestmap, res return handler, res
class queuedcommandfuture(pycompat.futures.Future): class queuedcommandfuture(pycompat.futures.Future):
"""Wraps result() on command futures to trigger submission on call.""" """Wraps result() on command futures to trigger submission on call."""
def result(self, timeout=None): def result(self, timeout=None):
if self.done(): if self.done():
return pycompat.futures.Future.result(self, timeout) return pycompat.futures.Future.result(self, timeout)
'permissions: %s') % 'permissions: %s') %
_(', ').join(sorted(permissions))) _(', ').join(sorted(permissions)))
permission = { permission = {
'push': 'rw', 'push': 'rw',
'pull': 'ro', 'pull': 'ro',
}[permissions.pop()] }[permissions.pop()]
reactor, requests, resp = sendv2request( handler, resp = sendv2request(
self._ui, self._opener, self._requestbuilder, self._apiurl, self._ui, self._opener, self._requestbuilder, self._apiurl,
permission, calls) permission, calls)
# TODO we probably want to validate the HTTP code, media type, etc. # TODO we probably want to validate the HTTP code, media type, etc.
self._responseexecutor = pycompat.futures.ThreadPoolExecutor(1) self._responseexecutor = pycompat.futures.ThreadPoolExecutor(1)
self._responsef = self._responseexecutor.submit(self._handleresponse, self._responsef = self._responseexecutor.submit(self._handleresponse,
reactor, handler, resp)
requests,
resp)
def close(self): def close(self):
if self._closed: if self._closed:
return return
self.sendcommands() self.sendcommands()
self._closed = True self._closed = True
# errored, otherwise a result() could wait indefinitely. # errored, otherwise a result() could wait indefinitely.
for f in self._futures: for f in self._futures:
if not f.done(): if not f.done():
f.set_exception(error.ResponseError( f.set_exception(error.ResponseError(
_('unfulfilled command response'))) _('unfulfilled command response')))
self._futures = None self._futures = None
def _handleresponse(self, reactor, requests, resp): def _handleresponse(self, handler, resp):
# Called in a thread to read the response. # Called in a thread to read the response.
results = {k: [] for k in requests} while handler.readframe(resp):
pass
while True:
frame = wireprotoframing.readframe(resp)
if frame is None:
break
self._ui.note(_('received %r\n') % frame)
# Guard against receiving a frame with a request ID that we
# didn't issue. This should never happen.
request, f = requests.get(frame.requestid, [None, None])
action, meta = reactor.onframerecv(frame)
if action == 'responsedata':
assert request.requestid == meta['request'].requestid
result = results[request.requestid]
if meta['cbor']:
payload = util.bytesio(meta['data'])
decoder = cbor.CBORDecoder(payload)
while payload.tell() + 1 < len(meta['data']):
try:
result.append(decoder.decode())
except Exception:
pycompat.future_set_exception_info(
f, sys.exc_info()[1:])
continue
else:
result.append(meta['data'])
if meta['eos']:
f.set_result(result)
del results[request.requestid]
elif action == 'error':
e = error.RepoError(meta['message'])
if f:
f.set_exception(e)
else:
raise e
else:
e = error.ProgrammingError('unhandled action: %s' % action)
if f:
f.set_exception(e)
else:
raise e
# TODO implement interface for version 2 peers # TODO implement interface for version 2 peers
@zi.implementer(repository.ipeerconnection, repository.ipeercapabilities, @zi.implementer(repository.ipeerconnection, repository.ipeercapabilities,
repository.ipeerrequests) repository.ipeerrequests)
class httpv2peer(object): class httpv2peer(object):
def __init__(self, ui, repourl, apipath, opener, requestbuilder, def __init__(self, ui, repourl, apipath, opener, requestbuilder,
apidescriptor): apidescriptor):
self.ui = ui self.ui = ui

mercurial/wireprotov2peer.py

  • This file was added.
# wireprotov2peer.py - client side code for wire protocol version 2
#
# Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com>
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.
from __future__ import absolute_import
from .i18n import _
from .thirdparty import (
cbor,
)
from . import (
error,
util,
wireprotoframing,
)
class clienthandler(object):
"""Object to handle higher-level client activities.
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
for higher-level operations, such as reading frames from a socket, exposing
and managing a higher-level primitive for representing command responses,
etc. This class is what peers should probably use to bridge wire activity
with the higher-level peer API.
"""
def __init__(self, ui, clientreactor):
self._ui = ui
self._reactor = clientreactor
self._requests = {}
self._futures = {}
self._responses = {}
def callcommand(self, command, args, f):
"""Register a request to call a command.
Returns an iterable of frames that should be sent over the wire.
"""
request, action, meta = self._reactor.callcommand(command, args)
if action != 'noop':
raise error.ProgrammingError('%s not yet supported' % action)
rid = request.requestid
self._requests[rid] = request
self._futures[rid] = f
self._responses[rid] = {
'cbor': False,
'b': util.bytesio(),
}
return iter(())
def flushcommands(self):
"""Flush all queued commands.
Returns an iterable of frames that should be sent over the wire.
"""
action, meta = self._reactor.flushcommands()
if action != 'sendframes':
raise error.ProgrammingError('%s not yet supported' % action)
return meta['framegen']
def readframe(self, fh):
"""Attempt to read and process a frame.
Returns None if no frame was read. Presumably this means EOF.
"""
frame = wireprotoframing.readframe(fh)
if frame is None:
# TODO tell reactor?
return
self._ui.note(_('received %r\n') % frame)
self._processframe(frame)
return True
def _processframe(self, frame):
"""Process a single read frame."""
action, meta = self._reactor.onframerecv(frame)
if action == 'error':
e = error.RepoError(meta['message'])
if frame.requestid in self._futures:
self._futures[frame.requestid].set_exception(e)
else:
raise e
if frame.requestid not in self._requests:
raise error.ProgrammingError(
'received frame for unknown request; this is either a bug in '
'the clientreactor not screening for this or this instance was '
'never told about this request: %r' % frame)
response = self._responses[frame.requestid]
if action == 'responsedata':
response['b'].write(meta['data'])
if meta['cbor']:
response['cbor'] = True
if meta['eos']:
if meta['cbor']:
# 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._futures[frame.requestid]
else:
raise error.ProgrammingError(
'unhandled action from clientreactor: %s' % action)

tests/test-wireproto-command-known.t

s> \r\n s> \r\n
s> 9\r\n s> 9\r\n
s> \x01\x00\x00\x01\x00\x02\x01F s> \x01\x00\x00\x01\x00\x02\x01F
s> @ s> @
s> \r\n s> \r\n
received frame(size=1; request=1; stream=2; streamflags=stream-begin; type=bytes-response; flags=eos|cbor) received frame(size=1; request=1; stream=2; streamflags=stream-begin; type=bytes-response; flags=eos|cbor)
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
response: [] response: [b'']
Single known node works Single known node works
$ sendhttpv2peer << EOF $ sendhttpv2peer << EOF
> command known > command known
> nodes eval:[b'\x42\x6b\xad\xa5\xc6\x75\x98\xca\x65\x03\x6d\x57\xd9\xe4\xb6\x4b\x0c\x1c\xe7\xa0'] > nodes eval:[b'\x42\x6b\xad\xa5\xc6\x75\x98\xca\x65\x03\x6d\x57\xd9\xe4\xb6\x4b\x0c\x1c\xe7\xa0']
> EOF > EOF
creating http peer for wire protocol version 2 creating http peer for wire protocol version 2

tests/test-wireproto-command-pushkey.t

s> \r\n s> \r\n
s> 9\r\n s> 9\r\n
s> *\x00\x01\x00\x02\x01F (glob) s> *\x00\x01\x00\x02\x01F (glob)
s> \xf5 s> \xf5
s> \r\n s> \r\n
received frame(size=*; request=1; stream=2; streamflags=stream-begin; type=bytes-response; flags=eos|cbor) (glob) received frame(size=*; request=1; stream=2; streamflags=stream-begin; type=bytes-response; flags=eos|cbor) (glob)
s> 0\r\n s> 0\r\n
s> \r\n s> \r\n
response: [] response: [True]
$ sendhttpv2peer << EOF $ sendhttpv2peer << EOF
> command listkeys > command listkeys
> namespace bookmarks > namespace bookmarks
> EOF > EOF
creating http peer for wire protocol version 2 creating http peer for wire protocol version 2
sending listkeys command sending listkeys command
s> POST /api/exp-http-v2-0001/ro/listkeys HTTP/1.1\r\n s> POST /api/exp-http-v2-0001/ro/listkeys HTTP/1.1\r\n