This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2832

hgweb: remove wsgirequest (API)
ClosedPublic

Authored by indygreg on Mar 12 2018, 5:39 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHGf0a851542a05: hgweb: remove wsgirequest (API)
Summary

Good riddance.

.. api::

The old ``wsgirequest`` class for handling everything WSGI in hgweb
has been replaced by separate request and response types. Various
high-level functions in the hgweb WSGI applications now receive
these new types as arguments instead of the old ``wsgirequest``
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.

Revision Contents
Changeset List

Diff 6966

mercurial/hgweb/hgweb_mod.py

"called while running as a CGI script.") "called while running as a CGI script.")
wsgicgi.launch(self) wsgicgi.launch(self)
def __call__(self, env, respond): def __call__(self, env, respond):
"""Run the WSGI application. """Run the WSGI application.
This may be called by multiple threads. This may be called by multiple threads.
""" """
req = requestmod.wsgirequest(env, respond) req = requestmod.parserequestfromenv(env)
return self.run_wsgi(req) res = requestmod.wsgiresponse(req, respond)
def run_wsgi(self, wsgireq): return self.run_wsgi(req, res)
def run_wsgi(self, req, res):
"""Internal method to run the WSGI application. """Internal method to run the WSGI application.
This is typically only called by Mercurial. External consumers This is typically only called by Mercurial. External consumers
should be using instances of this class as the WSGI application. should be using instances of this class as the WSGI application.
""" """
with self._obtainrepo() as repo: with self._obtainrepo() as repo:
profile = repo.ui.configbool('profiling', 'enabled') profile = repo.ui.configbool('profiling', 'enabled')
with profiling.profile(repo.ui, enabled=profile): with profiling.profile(repo.ui, enabled=profile):
for r in self._runwsgi(wsgireq, repo): for r in self._runwsgi(req, res, repo):
yield r yield r
def _runwsgi(self, wsgireq, repo): def _runwsgi(self, req, res, repo):
req = wsgireq.req
res = wsgireq.res
rctx = requestcontext(self, repo, req, res) rctx = requestcontext(self, repo, req, res)
# This state is global across all threads. # This state is global across all threads.
encoding.encoding = rctx.config('web', 'encoding') encoding.encoding = rctx.config('web', 'encoding')
rctx.repo.ui.environ = req.rawenv rctx.repo.ui.environ = req.rawenv
if rctx.csp: if rctx.csp:
# hgwebdir may have added CSP header. Since we generate our own, # hgwebdir may have added CSP header. Since we generate our own,

mercurial/hgweb/hgwebdir_mod.py

if not encoding.environ.get('GATEWAY_INTERFACE', if not encoding.environ.get('GATEWAY_INTERFACE',
'').startswith("CGI/1."): '').startswith("CGI/1."):
raise RuntimeError("This function is only intended to be " raise RuntimeError("This function is only intended to be "
"called while running as a CGI script.") "called while running as a CGI script.")
wsgicgi.launch(self) wsgicgi.launch(self)
def __call__(self, env, respond): def __call__(self, env, respond):
baseurl = self.ui.config('web', 'baseurl') baseurl = self.ui.config('web', 'baseurl')
wsgireq = requestmod.wsgirequest(env, respond, altbaseurl=baseurl) req = requestmod.parserequestfromenv(env, altbaseurl=baseurl)
return self.run_wsgi(wsgireq) res = requestmod.wsgiresponse(req, respond)
def run_wsgi(self, wsgireq): return self.run_wsgi(req, res)
def run_wsgi(self, req, res):
profile = self.ui.configbool('profiling', 'enabled') profile = self.ui.configbool('profiling', 'enabled')
with profiling.profile(self.ui, enabled=profile): with profiling.profile(self.ui, enabled=profile):
for r in self._runwsgi(wsgireq): for r in self._runwsgi(req, res):
yield r yield r
def _runwsgi(self, wsgireq): def _runwsgi(self, req, res):
req = wsgireq.req
res = wsgireq.res
try: try:
self.refresh() self.refresh()
csp, nonce = cspvalues(self.ui) csp, nonce = cspvalues(self.ui)
if csp: if csp:
res.headers['Content-Security-Policy'] = csp res.headers['Content-Security-Policy'] = csp
virtual = req.dispatchpath.strip('/') virtual = req.dispatchpath.strip('/')
yield '' yield ''
for virtualrepo in _virtualdirs(): for virtualrepo in _virtualdirs():
real = repos.get(virtualrepo) real = repos.get(virtualrepo)
if real: if real:
# Re-parse the WSGI environment to take into account our # Re-parse the WSGI environment to take into account our
# repository path component. # repository path component.
wsgireq.req = requestmod.parserequestfromenv( req = requestmod.parserequestfromenv(
wsgireq.env, wsgireq.req.bodyfh, reponame=virtualrepo, req.rawenv, reponame=virtualrepo,
altbaseurl=self.ui.config('web', 'baseurl')) altbaseurl=self.ui.config('web', 'baseurl'))
try: try:
# ensure caller gets private copy of ui # ensure caller gets private copy of ui
repo = hg.repository(self.ui.copy(), real) repo = hg.repository(self.ui.copy(), real)
return hgweb_mod.hgweb(repo).run_wsgi(wsgireq) return hgweb_mod.hgweb(repo).run_wsgi(req, res)
except IOError as inst: except IOError as inst:
msg = encoding.strtolocal(inst.strerror) msg = encoding.strtolocal(inst.strerror)
raise ErrorResponse(HTTP_SERVER_ERROR, msg) raise ErrorResponse(HTTP_SERVER_ERROR, msg)
except error.RepoError as inst: except error.RepoError as inst:
raise ErrorResponse(HTTP_SERVER_ERROR, bytes(inst)) raise ErrorResponse(HTTP_SERVER_ERROR, bytes(inst))
# browse subdirectories # browse subdirectories
subdir = virtual + '/' subdir = virtual + '/'

mercurial/hgweb/request.py

# wsgiref.headers.Headers instance. Operates like a dict with case # wsgiref.headers.Headers instance. Operates like a dict with case
# insensitive keys. # insensitive keys.
headers = attr.ib() headers = attr.ib()
# Request body input stream. # Request body input stream.
bodyfh = attr.ib() bodyfh = attr.ib()
# WSGI environment dict, unmodified. # WSGI environment dict, unmodified.
rawenv = attr.ib() rawenv = attr.ib()
def parserequestfromenv(env, bodyfh, reponame=None, altbaseurl=None): def parserequestfromenv(env, reponame=None, altbaseurl=None):
"""Parse URL components from environment variables. """Parse URL components from environment variables.
WSGI defines request attributes via environment variables. This function WSGI defines request attributes via environment variables. This function
parses the environment variables into a data structure. parses the environment variables into a data structure.
If ``reponame`` is defined, the leading path components matching that If ``reponame`` is defined, the leading path components matching that
string are effectively shifted from ``PATH_INFO`` to ``SCRIPT_NAME``. string are effectively shifted from ``PATH_INFO`` to ``SCRIPT_NAME``.
This simulates the world view of a WSGI application that processes This simulates the world view of a WSGI application that processes
# This is kind of a lie because the HTTP header wasn't explicitly # This is kind of a lie because the HTTP header wasn't explicitly
# sent. But for all intents and purposes it should be OK to lie about # sent. But for all intents and purposes it should be OK to lie about
# this, since a consumer will either either value to determine how many # this, since a consumer will either either value to determine how many
# bytes are available to read. # bytes are available to read.
if 'CONTENT_LENGTH' in env and 'HTTP_CONTENT_LENGTH' not in env: if 'CONTENT_LENGTH' in env and 'HTTP_CONTENT_LENGTH' not in env:
headers['Content-Length'] = env['CONTENT_LENGTH'] headers['Content-Length'] = env['CONTENT_LENGTH']
# TODO do this once we remove wsgirequest.inp, otherwise we could have bodyfh = env['wsgi.input']
# multiple readers from the underlying input stream. if 'Content-Length' in headers:
#bodyfh = env['wsgi.input'] bodyfh = util.cappedreader(bodyfh, int(headers['Content-Length']))
#if 'Content-Length' in headers:
# bodyfh = util.cappedreader(bodyfh, int(headers['Content-Length']))
return parsedrequest(method=env['REQUEST_METHOD'], return parsedrequest(method=env['REQUEST_METHOD'],
url=fullurl, baseurl=baseurl, url=fullurl, baseurl=baseurl,
advertisedurl=advertisedfullurl, advertisedurl=advertisedfullurl,
advertisedbaseurl=advertisedbaseurl, advertisedbaseurl=advertisedbaseurl,
urlscheme=env['wsgi.url_scheme'], urlscheme=env['wsgi.url_scheme'],
remoteuser=env.get('REMOTE_USER'), remoteuser=env.get('REMOTE_USER'),
remotehost=env.get('REMOTE_HOST'), remotehost=env.get('REMOTE_HOST'),
if not self._started: if not self._started:
raise error.ProgrammingError('must call sendresponse() first; did ' raise error.ProgrammingError('must call sendresponse() first; did '
'you remember to consume it since it ' 'you remember to consume it since it '
'is a generator?') 'is a generator?')
assert self._bodywritefn assert self._bodywritefn
return offsettrackingwriter(self._bodywritefn) return offsettrackingwriter(self._bodywritefn)
class wsgirequest(object):
"""Higher-level API for a WSGI request.
WSGI applications are invoked with 2 arguments. They are used to
instantiate instances of this class, which provides higher-level APIs
for obtaining request parameters, writing HTTP output, etc.
"""
def __init__(self, wsgienv, start_response, altbaseurl=None):
version = wsgienv[r'wsgi.version']
if (version < (1, 0)) or (version >= (2, 0)):
raise RuntimeError("Unknown and unsupported WSGI version %d.%d"
% version)
inp = wsgienv[r'wsgi.input']
if r'HTTP_CONTENT_LENGTH' in wsgienv:
inp = util.cappedreader(inp, int(wsgienv[r'HTTP_CONTENT_LENGTH']))
elif r'CONTENT_LENGTH' in wsgienv:
inp = util.cappedreader(inp, int(wsgienv[r'CONTENT_LENGTH']))
self.err = wsgienv[r'wsgi.errors']
self.threaded = wsgienv[r'wsgi.multithread']
self.multiprocess = wsgienv[r'wsgi.multiprocess']
self.run_once = wsgienv[r'wsgi.run_once']
self.env = wsgienv
self.req = parserequestfromenv(wsgienv, inp, altbaseurl=altbaseurl)
self.res = wsgiresponse(self.req, start_response)
def wsgiapplication(app_maker): def wsgiapplication(app_maker):
'''For compatibility with old CGI scripts. A plain hgweb() or hgwebdir() '''For compatibility with old CGI scripts. A plain hgweb() or hgwebdir()
can and should now be used as a WSGI application.''' can and should now be used as a WSGI application.'''
application = app_maker() application = app_maker()
def run_wsgi(env, respond): def run_wsgi(env, respond):
return application(env, respond) return application(env, respond)
return run_wsgi return run_wsgi

tests/test-wsgirequest.py

r'wsgi.url_scheme': r'http', r'wsgi.url_scheme': r'http',
r'wsgi.input': None, r'wsgi.input': None,
r'wsgi.errors': None, r'wsgi.errors': None,
r'wsgi.multithread': False, r'wsgi.multithread': False,
r'wsgi.multiprocess': True, r'wsgi.multiprocess': True,
r'wsgi.run_once': False, r'wsgi.run_once': False,
} }
def parse(env, bodyfh=None, reponame=None, altbaseurl=None, extra=None): def parse(env, reponame=None, altbaseurl=None, extra=None):
env = dict(env) env = dict(env)
env.update(extra or {}) env.update(extra or {})
return requestmod.parserequestfromenv(env, bodyfh, reponame=reponame, return requestmod.parserequestfromenv(env, reponame=reponame,
altbaseurl=altbaseurl) altbaseurl=altbaseurl)
class ParseRequestTests(unittest.TestCase): class ParseRequestTests(unittest.TestCase):
def testdefault(self): def testdefault(self):
r = parse(DEFAULT_ENV) r = parse(DEFAULT_ENV)
self.assertEqual(r.url, b'http://testserver') self.assertEqual(r.url, b'http://testserver')
self.assertEqual(r.baseurl, b'http://testserver') self.assertEqual(r.baseurl, b'http://testserver')
self.assertEqual(r.advertisedurl, b'http://testserver') self.assertEqual(r.advertisedurl, b'http://testserver')