This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2743

wireprotoserver: access headers through parsed request
ClosedPublic

Authored by indygreg on Mar 8 2018, 8:06 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG14f70c44af6c: wireprotoserver: access headers through parsed request
Summary

Now that we can access headers via the parsed request object, let's
do that.

Since the new object uses bytes, hyphens, and is case-insensitive, a
bit of code around normalizing values has been removed. I think
the new code is much more intuitive because it more closely matches
what is going out over the wire.

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.Mar 8 2018, 8:06 PM
durin42 added a subscriber: durin42.Mar 9 2018, 2:26 PM
durin42 added inline comments.
mercurial/wireprotoserver.py
97

Missed one?

indygreg added inline comments.Mar 9 2018, 6:10 PM
mercurial/wireprotoserver.py
97

No. This preserves the behavior since HTTP_CONTENT_LENGTH != CONTENT_LENGTH. I fix this in a later commit by teaching the request object about both keys.

durin42 accepted this revision.Mar 12 2018, 4:48 PM
This revision is now accepted and ready to land.Mar 12 2018, 4:48 PM
Closed by commit rHG14f70c44af6c: wireprotoserver: access headers through parsed request (authored by indygreg). · Explain WhyMar 12 2018, 5:31 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/wireprotoserver.py (39 lines)

Diff 6898

mercurial/wireprotoserver.py

HGTYPE = 'application/mercurial-0.1' HGTYPE = 'application/mercurial-0.1'
HGTYPE2 = 'application/mercurial-0.2' HGTYPE2 = 'application/mercurial-0.2'
HGERRTYPE = 'application/hg-error' HGERRTYPE = 'application/hg-error'
SSHV1 = wireprototypes.SSHV1 SSHV1 = wireprototypes.SSHV1
SSHV2 = wireprototypes.SSHV2 SSHV2 = wireprototypes.SSHV2
def decodevaluefromheaders(wsgireq, headerprefix): def decodevaluefromheaders(req, headerprefix):
"""Decode a long value from multiple HTTP request headers. """Decode a long value from multiple HTTP request headers.
Returns the value as a bytes, not a str. Returns the value as a bytes, not a str.
""" """
chunks = [] chunks = []
i = 1 i = 1
prefix = headerprefix.upper().replace(r'-', r'_')
while True: while True:
v = wsgireq.env.get(r'HTTP_%s_%d' % (prefix, i)) v = req.headers.get(b'%s-%d' % (headerprefix, i))
if v is None: if v is None:
break break
chunks.append(pycompat.bytesurl(v)) chunks.append(pycompat.bytesurl(v))
i += 1 i += 1
return ''.join(chunks) return ''.join(chunks)
class httpv1protocolhandler(wireprototypes.baseprotocolhandler): class httpv1protocolhandler(wireprototypes.baseprotocolhandler):
def __init__(self, wsgireq, ui, checkperm): def __init__(self, wsgireq, req, ui, checkperm):
self._wsgireq = wsgireq self._wsgireq = wsgireq
self._req = req
self._ui = ui self._ui = ui
self._checkperm = checkperm self._checkperm = checkperm
@property @property
def name(self): def name(self):
return 'http-v1' return 'http-v1'
def getargs(self, args): def getargs(self, args):
knownargs = self._args() knownargs = self._args()
data = {} data = {}
keys = args.split() keys = args.split()
for k in keys: for k in keys:
if k == '*': if k == '*':
star = {} star = {}
for key in knownargs.keys(): for key in knownargs.keys():
if key != 'cmd' and key not in keys: if key != 'cmd' and key not in keys:
star[key] = knownargs[key][0] star[key] = knownargs[key][0]
data['*'] = star data['*'] = star
else: else:
data[k] = knownargs[k][0] data[k] = knownargs[k][0]
return [data[k] for k in keys] return [data[k] for k in keys]
def _args(self): def _args(self):
args = util.rapply(pycompat.bytesurl, self._wsgireq.form.copy()) args = util.rapply(pycompat.bytesurl, self._wsgireq.form.copy())
postlen = int(self._wsgireq.env.get(r'HTTP_X_HGARGS_POST', 0)) postlen = int(self._req.headers.get(b'X-HgArgs-Post', 0))
if postlen: if postlen:
args.update(urlreq.parseqs( args.update(urlreq.parseqs(
self._wsgireq.read(postlen), keep_blank_values=True)) self._wsgireq.read(postlen), keep_blank_values=True))
return args return args
argvalue = decodevaluefromheaders(self._wsgireq, r'X-HgArg') argvalue = decodevaluefromheaders(self._req, b'X-HgArg')
args.update(urlreq.parseqs(argvalue, keep_blank_values=True)) args.update(urlreq.parseqs(argvalue, keep_blank_values=True))
return args return args
def forwardpayload(self, fp): def forwardpayload(self, fp):
if r'HTTP_CONTENT_LENGTH' in self._wsgireq.env: if b'Content-Length' in self._req.headers:
length = int(self._wsgireq.env[r'HTTP_CONTENT_LENGTH']) length = int(self._req.headers[b'Content-Length'])
else: else:
length = int(self._wsgireq.env[r'CONTENT_LENGTH']) length = int(self._wsgireq.env[r'CONTENT_LENGTH'])
durin42Unsubmitted
Not Done

Missed one?

durin42: Missed one?
indygregAuthorUnsubmitted
Not Done

No. This preserves the behavior since HTTP_CONTENT_LENGTH != CONTENT_LENGTH. I fix this in a later commit by teaching the request object about both keys.

indygreg: No. This preserves the behavior since HTTP_CONTENT_LENGTH != CONTENT_LENGTH. I fix this in a…
# If httppostargs is used, we need to read Content-Length # If httppostargs is used, we need to read Content-Length
# minus the amount that was consumed by args. # minus the amount that was consumed by args.
length -= int(self._wsgireq.env.get(r'HTTP_X_HGARGS_POST', 0)) length -= int(self._req.headers.get(b'X-HgArgs-Post', 0))
for s in util.filechunkiter(self._wsgireq, limit=length): for s in util.filechunkiter(self._wsgireq, limit=length):
fp.write(s) fp.write(s)
@contextlib.contextmanager @contextlib.contextmanager
def mayberedirectstdio(self): def mayberedirectstdio(self):
oldout = self._ui.fout oldout = self._ui.fout
olderr = self._ui.ferr olderr = self._ui.ferr
# The "cmd" query string argument is only valid on the root path of the # The "cmd" query string argument is only valid on the root path of the
# repo. e.g. ``/?cmd=foo``, ``/repo?cmd=foo``. URL paths within the repo # repo. e.g. ``/?cmd=foo``, ``/repo?cmd=foo``. URL paths within the repo
# like ``/blah?cmd=foo`` are not allowed. So don't recognize the request # like ``/blah?cmd=foo`` are not allowed. So don't recognize the request
# in this case. We send an HTTP 404 for backwards compatibility reasons. # in this case. We send an HTTP 404 for backwards compatibility reasons.
if req.dispatchpath: if req.dispatchpath:
res = _handlehttperror( res = _handlehttperror(
hgwebcommon.ErrorResponse(hgwebcommon.HTTP_NOT_FOUND), wsgireq, hgwebcommon.ErrorResponse(hgwebcommon.HTTP_NOT_FOUND), wsgireq,
cmd) req, cmd)
return True, res return True, res
proto = httpv1protocolhandler(wsgireq, repo.ui, proto = httpv1protocolhandler(wsgireq, req, repo.ui,
lambda perm: checkperm(rctx, wsgireq, perm)) lambda perm: checkperm(rctx, wsgireq, perm))
# The permissions checker should be the only thing that can raise an # The permissions checker should be the only thing that can raise an
# ErrorResponse. It is kind of a layer violation to catch an hgweb # ErrorResponse. It is kind of a layer violation to catch an hgweb
# exception here. So consider refactoring into a exception type that # exception here. So consider refactoring into a exception type that
# is associated with the wire protocol. # is associated with the wire protocol.
try: try:
res = _callhttp(repo, wsgireq, proto, cmd) res = _callhttp(repo, wsgireq, req, proto, cmd)
except hgwebcommon.ErrorResponse as e: except hgwebcommon.ErrorResponse as e:
res = _handlehttperror(e, wsgireq, cmd) res = _handlehttperror(e, wsgireq, req, cmd)
return True, res return True, res
def _httpresponsetype(ui, wsgireq, prefer_uncompressed): def _httpresponsetype(ui, req, prefer_uncompressed):
"""Determine the appropriate response type and compression settings. """Determine the appropriate response type and compression settings.
Returns a tuple of (mediatype, compengine, engineopts). Returns a tuple of (mediatype, compengine, engineopts).
""" """
# Determine the response media type and compression engine based # Determine the response media type and compression engine based
# on the request parameters. # on the request parameters.
protocaps = decodevaluefromheaders(wsgireq, r'X-HgProto').split(' ') protocaps = decodevaluefromheaders(req, 'X-HgProto').split(' ')
if '0.2' in protocaps: if '0.2' in protocaps:
# All clients are expected to support uncompressed data. # All clients are expected to support uncompressed data.
if prefer_uncompressed: if prefer_uncompressed:
return HGTYPE2, util._noopengine(), {} return HGTYPE2, util._noopengine(), {}
# Default as defined by wire protocol spec. # Default as defined by wire protocol spec.
compformats = ['zlib', 'none'] compformats = ['zlib', 'none']
# legacy protocol. # legacy protocol.
# Don't allow untrusted settings because disabling compression or # Don't allow untrusted settings because disabling compression or
# 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': ui.configint('server', 'zliblevel')} opts = {'level': ui.configint('server', 'zliblevel')}
return HGTYPE, util.compengines['zlib'], opts return HGTYPE, util.compengines['zlib'], opts
def _callhttp(repo, wsgireq, proto, cmd): def _callhttp(repo, wsgireq, 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
wsgireq.respond(HTTP_OK, HGTYPE) wsgireq.respond(HTTP_OK, HGTYPE)
return gen return gen
elif isinstance(rsp, wireprototypes.streamres): elif isinstance(rsp, wireprototypes.streamres):
gen = rsp.gen gen = rsp.gen
# This code for compression should not be streamres specific. It # This code for compression should not be streamres specific. It
# is here because we only compress streamres at the moment. # is here because we only compress streamres at the moment.
mediatype, engine, engineopts = _httpresponsetype( mediatype, engine, engineopts = _httpresponsetype(
repo.ui, wsgireq, rsp.prefer_uncompressed) repo.ui, req, rsp.prefer_uncompressed)
gen = engine.compressstream(gen, engineopts) gen = engine.compressstream(gen, engineopts)
if mediatype == HGTYPE2: if mediatype == HGTYPE2:
gen = genversion2(gen, engine, engineopts) gen = genversion2(gen, engine, engineopts)
wsgireq.respond(HTTP_OK, mediatype) wsgireq.respond(HTTP_OK, mediatype)
return gen return gen
elif isinstance(rsp, wireprototypes.pushres): elif isinstance(rsp, wireprototypes.pushres):
rsp = '%d\n%s' % (rsp.res, rsp.output) rsp = '%d\n%s' % (rsp.res, rsp.output)
wsgireq.respond(HTTP_OK, HGTYPE, body=rsp) wsgireq.respond(HTTP_OK, HGTYPE, body=rsp)
return [] return []
elif isinstance(rsp, wireprototypes.pusherr): elif isinstance(rsp, wireprototypes.pusherr):
# This is the httplib workaround documented in _handlehttperror(). # This is the httplib workaround documented in _handlehttperror().
wsgireq.drain() wsgireq.drain()
rsp = '0\n%s\n' % rsp.res rsp = '0\n%s\n' % rsp.res
wsgireq.respond(HTTP_OK, HGTYPE, body=rsp) wsgireq.respond(HTTP_OK, HGTYPE, body=rsp)
return [] return []
elif isinstance(rsp, wireprototypes.ooberror): elif isinstance(rsp, wireprototypes.ooberror):
rsp = rsp.message rsp = rsp.message
wsgireq.respond(HTTP_OK, HGERRTYPE, body=rsp) wsgireq.respond(HTTP_OK, HGERRTYPE, body=rsp)
return [] return []
raise error.ProgrammingError('hgweb.protocol internal failure', rsp) raise error.ProgrammingError('hgweb.protocol internal failure', rsp)
def _handlehttperror(e, wsgireq, cmd): def _handlehttperror(e, wsgireq, req, cmd):
"""Called when an ErrorResponse is raised during HTTP request processing.""" """Called when an ErrorResponse is raised during HTTP request processing."""
# Clients using Python's httplib are stateful: the HTTP client # Clients using Python's httplib are stateful: the HTTP client
# won't process an HTTP response until all request data is # won't process an HTTP response until all request data is
# sent to the server. The intent of this code is to ensure # sent to the server. The intent of this code is to ensure
# we always read HTTP request data from the client, thus # we always read HTTP request data from the client, thus
# ensuring httplib transitions to a state that allows it to read # ensuring httplib transitions to a state that allows it to read
# the HTTP response. In other words, it helps prevent deadlocks # the HTTP response. In other words, it helps prevent deadlocks
# on clients using httplib. # on clients using httplib.
if (wsgireq.env[r'REQUEST_METHOD'] == r'POST' and if (wsgireq.env[r'REQUEST_METHOD'] == r'POST' and
# But not if Expect: 100-continue is being used. # But not if Expect: 100-continue is being used.
(wsgireq.env.get('HTTP_EXPECT', (req.headers.get('Expect', '').lower() != '100-continue')):
'').lower() != '100-continue')):
wsgireq.drain() wsgireq.drain()
else: else:
wsgireq.headers.append((r'Connection', r'Close')) wsgireq.headers.append((r'Connection', r'Close'))
# TODO This response body assumes the failed command was # TODO This response body assumes the failed command was
# "unbundle." That assumption is not always valid. # "unbundle." That assumption is not always valid.
wsgireq.respond(e, HGTYPE, body='0\n%s\n' % pycompat.bytestr(e)) wsgireq.respond(e, HGTYPE, body='0\n%s\n' % pycompat.bytestr(e))