This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2019

wireprotoserver: move protocol parsing and dispatch out of hgweb
ClosedPublic

Authored by indygreg on Feb 2 2018, 8:50 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHGcdc93fe1da77: wireprotoserver: move protocol parsing and dispatch out of hgweb
Summary

Previously, hgweb_mod had code for detecting if the request
was for the wire protocol. It would then (eventually) call
wireprotoserver.callhttp() to dispatch the request handling.

Detection of wire protocol requests is not trivial. There's
currently a big gotcha in the handling of the "cmd" request
parameter, for example.

Furthermore, in the near future we will have a second HTTP
protocol handler. Its mechanism for calling commands will be
a bit different. And we don't want the low-level logic for
detecting protocol commands to live in hgweb.

We establish a new function in wireprotoserver for detecting
an HTTP protocol request and for giving the caller an easy-to-use
mechanism for dispatching requests to it.

Some wire protocol specific functionality still lives in hgweb.
This will be addressed in subsequent commits.

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.Feb 2 2018, 8:50 PM
indygreg updated this revision to Diff 5259.Feb 6 2018, 4:04 PM
durin42 accepted this revision.Feb 7 2018, 5:18 PM
This revision is now accepted and ready to land.Feb 7 2018, 5:18 PM
Closed by commit rHGcdc93fe1da77: wireprotoserver: move protocol parsing and dispatch out of hgweb (authored by indygreg). · Explain WhyFeb 7 2018, 5:41 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 5309

mercurial/hgweb/hgweb_mod.py

repo_parts = req.env.get(r'REPO_NAME', r'').split(r'/') repo_parts = req.env.get(r'REPO_NAME', r'').split(r'/')
if parts[:len(repo_parts)] == repo_parts: if parts[:len(repo_parts)] == repo_parts:
parts = parts[len(repo_parts):] parts = parts[len(repo_parts):]
query = '/'.join(parts) query = '/'.join(parts)
else: else:
query = req.env[r'QUERY_STRING'].partition(r'&')[0] query = req.env[r'QUERY_STRING'].partition(r'&')[0]
query = query.partition(r';')[0] query = query.partition(r';')[0]
# The ``cmd`` request parameter is used by both the wire protocol # Route it to a wire protocol handler if it looks like a wire protocol
# and hgweb. We route all known wire protocol commands to the # request.
# wire protocol handler, even if the command isn't available for protohandler = wireprotoserver.parsehttprequest(rctx.repo, req, query)
# this transport. That's better for machine clients in the case
# of an errant request to an unavailable protocol command. And it
# prevents hgweb from accidentally using ``cmd`` values used by
# the wire protocol.
# process this if it's a protocol request
# protocol bits don't need to create any URLs
# and the clients always use the old URL structure
cmd = pycompat.sysbytes(req.form.get(r'cmd', [r''])[0]) if protohandler:
if wireprotoserver.iscmd(cmd): cmd = protohandler['cmd']
try: try:
if query: if query:
raise ErrorResponse(HTTP_NOT_FOUND) raise ErrorResponse(HTTP_NOT_FOUND)
if cmd in perms: if cmd in perms:
self.check_perm(rctx, req, perms[cmd]) self.check_perm(rctx, req, perms[cmd])
return wireprotoserver.callhttp(rctx.repo, req, cmd) return protohandler['dispatch']()
except ErrorResponse as inst: except ErrorResponse as inst:
# A client that sends unbundle without 100-continue will # A client that sends unbundle without 100-continue will
# break if we respond early. # break if we respond early.
if (cmd == 'unbundle' and if (cmd == 'unbundle' and
(req.env.get('HTTP_EXPECT', (req.env.get('HTTP_EXPECT',
'').lower() != '100-continue') or '').lower() != '100-continue') or
req.env.get('X-HgHttp2', '')): req.env.get('X-HgHttp2', '')):
req.drain() req.drain()
if cmd == 'archive': if cmd == 'archive':
fn = req.form['node'][0] fn = req.form['node'][0]
for type_, spec in rctx.archivespecs.iteritems(): for type_, spec in rctx.archivespecs.iteritems():
ext = spec[2] ext = spec[2]
if fn.endswith(ext): if fn.endswith(ext):
req.form['node'] = [fn[:-len(ext)]] req.form['node'] = [fn[:-len(ext)]]
req.form['type'] = [type_] req.form['type'] = [type_]
else:
cmd = pycompat.sysbytes(req.form.get(r'cmd', [r''])[0])
# process the web interface request # process the web interface request
try: try:
tmpl = rctx.templater(req) tmpl = rctx.templater(req)
ctype = tmpl('mimetype', encoding=encoding.encoding) ctype = tmpl('mimetype', encoding=encoding.encoding)
ctype = templater.stringify(ctype) ctype = templater.stringify(ctype)

mercurial/wireprotoserver.py

# setting a very high compression level could lead to flooding # setting a very high compression level could lead to flooding
# the server's network or CPU. # the server's network or CPU.
opts = {'level': self._ui.configint('server', 'zliblevel')} opts = {'level': self._ui.configint('server', 'zliblevel')}
return HGTYPE, util.compengines['zlib'], opts return HGTYPE, util.compengines['zlib'], opts
def iscmd(cmd): def iscmd(cmd):
return cmd in wireproto.commands return cmd in wireproto.commands
def callhttp(repo, req, cmd): def parsehttprequest(repo, req, query):
"""Parse the HTTP request for a wire protocol request.
If the current request appears to be a wire protocol request, this
function returns a dict with details about that request, including
an ``abstractprotocolserver`` instance suitable for handling the
request. Otherwise, ``None`` is returned.
``req`` is a ``wsgirequest`` instance.
"""
# HTTP version 1 wire protocol requests are denoted by a "cmd" query
# string parameter. If it isn't present, this isn't a wire protocol
# request.
if r'cmd' not in req.form:
return None
cmd = pycompat.sysbytes(req.form[r'cmd'][0])
# The "cmd" request parameter is used by both the wire protocol and hgweb.
# While not all wire protocol commands are available for all transports,
# if we see a "cmd" value that resembles a known wire protocol command, we
# route it to a protocol handler. This is better than routing possible
# wire protocol requests to hgweb because it prevents hgweb from using
# known wire protocol commands and it is less confusing for machine
# clients.
if cmd not in wireproto.commands:
return None
proto = webproto(req, repo.ui) proto = webproto(req, repo.ui)
return {
'cmd': cmd,
'proto': proto,
'dispatch': lambda: _callhttp(repo, req, proto, cmd),
}
def _callhttp(repo, req, proto, cmd):
def genversion2(gen, engine, engineopts): def genversion2(gen, engine, engineopts):
# application/mercurial-0.2 always sends a payload header # application/mercurial-0.2 always sends a payload header
# identifying the compression engine. # identifying the compression engine.
name = engine.wireprotosupport().name name = engine.wireprotosupport().name
assert 0 < len(name) < 256 assert 0 < len(name) < 256
yield struct.pack('B', len(name)) yield struct.pack('B', len(name))
yield name yield name