--- a/mercurial/hgweb/hgweb_mod.py Thu Mar 08 09:44:27 2018 -0800
+++ b/mercurial/hgweb/hgweb_mod.py Thu Mar 08 15:15:59 2018 -0800
@@ -22,7 +22,6 @@
cspvalues,
permhooks,
)
-from .request import wsgirequest
from .. import (
encoding,
@@ -41,6 +40,7 @@
)
from . import (
+ request as requestmod,
webcommands,
webutil,
wsgicgi,
@@ -142,11 +142,11 @@
if typ in allowed or self.configbool('web', 'allow%s' % typ):
yield {'type': typ, 'extension': spec[2], 'node': nodeid}
- def templater(self, req):
+ def templater(self, wsgireq):
# determine scheme, port and server name
# this is needed to create absolute urls
- proto = req.env.get('wsgi.url_scheme')
+ proto = wsgireq.env.get('wsgi.url_scheme')
if proto == 'https':
proto = 'https'
default_port = '443'
@@ -154,13 +154,13 @@
proto = 'http'
default_port = '80'
- port = req.env[r'SERVER_PORT']
+ port = wsgireq.env[r'SERVER_PORT']
port = port != default_port and (r':' + port) or r''
- urlbase = r'%s://%s%s' % (proto, req.env[r'SERVER_NAME'], port)
+ urlbase = r'%s://%s%s' % (proto, wsgireq.env[r'SERVER_NAME'], port)
logourl = self.config('web', 'logourl')
logoimg = self.config('web', 'logoimg')
staticurl = (self.config('web', 'staticurl')
- or pycompat.sysbytes(req.url) + 'static/')
+ or pycompat.sysbytes(wsgireq.url) + 'static/')
if not staticurl.endswith('/'):
staticurl += '/'
@@ -172,18 +172,18 @@
# figure out which style to use
vars = {}
- styles, (style, mapfile) = getstyle(req, self.config,
+ styles, (style, mapfile) = getstyle(wsgireq, self.config,
self.templatepath)
if style == styles[0]:
vars['style'] = style
- start = '&' if req.url[-1] == r'?' else '?'
+ start = '&' if wsgireq.url[-1] == r'?' else '?'
sessionvars = webutil.sessionvars(vars, start)
if not self.reponame:
self.reponame = (self.config('web', 'name', '')
- or req.env.get('REPO_NAME')
- or req.url.strip(r'/') or self.repo.root)
+ or wsgireq.env.get('REPO_NAME')
+ or wsgireq.url.strip(r'/') or self.repo.root)
def websubfilter(text):
return templatefilters.websub(text, self.websubtable)
@@ -191,7 +191,7 @@
# create the templater
# TODO: export all keywords: defaults = templatekw.keywords.copy()
defaults = {
- 'url': pycompat.sysbytes(req.url),
+ 'url': pycompat.sysbytes(wsgireq.url),
'logourl': logourl,
'logoimg': logoimg,
'staticurl': staticurl,
@@ -200,7 +200,7 @@
'encoding': encoding.encoding,
'motd': motd,
'sessionvars': sessionvars,
- 'pathdef': makebreadcrumb(pycompat.sysbytes(req.url)),
+ 'pathdef': makebreadcrumb(pycompat.sysbytes(wsgireq.url)),
'style': style,
'nonce': self.nonce,
}
@@ -301,10 +301,10 @@
This may be called by multiple threads.
"""
- req = wsgirequest(env, respond)
+ req = requestmod.wsgirequest(env, respond)
return self.run_wsgi(req)
- def run_wsgi(self, req):
+ def run_wsgi(self, wsgireq):
"""Internal method to run the WSGI application.
This is typically only called by Mercurial. External consumers
@@ -313,45 +313,45 @@
with self._obtainrepo() as repo:
profile = repo.ui.configbool('profiling', 'enabled')
with profiling.profile(repo.ui, enabled=profile):
- for r in self._runwsgi(req, repo):
+ for r in self._runwsgi(wsgireq, repo):
yield r
- def _runwsgi(self, req, repo):
+ def _runwsgi(self, wsgireq, repo):
rctx = requestcontext(self, repo)
# This state is global across all threads.
encoding.encoding = rctx.config('web', 'encoding')
- rctx.repo.ui.environ = req.env
+ rctx.repo.ui.environ = wsgireq.env
if rctx.csp:
# hgwebdir may have added CSP header. Since we generate our own,
# replace it.
- req.headers = [h for h in req.headers
- if h[0] != 'Content-Security-Policy']
- req.headers.append(('Content-Security-Policy', rctx.csp))
+ wsgireq.headers = [h for h in wsgireq.headers
+ if h[0] != 'Content-Security-Policy']
+ wsgireq.headers.append(('Content-Security-Policy', rctx.csp))
# work with CGI variables to create coherent structure
# use SCRIPT_NAME, PATH_INFO and QUERY_STRING as well as our REPO_NAME
- req.url = req.env[r'SCRIPT_NAME']
- if not req.url.endswith(r'/'):
- req.url += r'/'
- if req.env.get('REPO_NAME'):
- req.url += req.env[r'REPO_NAME'] + r'/'
+ wsgireq.url = wsgireq.env[r'SCRIPT_NAME']
+ if not wsgireq.url.endswith(r'/'):
+ wsgireq.url += r'/'
+ if wsgireq.env.get('REPO_NAME'):
+ wsgireq.url += wsgireq.env[r'REPO_NAME'] + r'/'
- if r'PATH_INFO' in req.env:
- parts = req.env[r'PATH_INFO'].strip(r'/').split(r'/')
- repo_parts = req.env.get(r'REPO_NAME', r'').split(r'/')
+ if r'PATH_INFO' in wsgireq.env:
+ parts = wsgireq.env[r'PATH_INFO'].strip(r'/').split(r'/')
+ repo_parts = wsgireq.env.get(r'REPO_NAME', r'').split(r'/')
if parts[:len(repo_parts)] == repo_parts:
parts = parts[len(repo_parts):]
query = r'/'.join(parts)
else:
- query = req.env[r'QUERY_STRING'].partition(r'&')[0]
+ query = wsgireq.env[r'QUERY_STRING'].partition(r'&')[0]
query = query.partition(r';')[0]
# Route it to a wire protocol handler if it looks like a wire protocol
# request.
- protohandler = wireprotoserver.parsehttprequest(rctx, req, query,
+ protohandler = wireprotoserver.parsehttprequest(rctx, wsgireq, query,
self.check_perm)
if protohandler:
@@ -366,83 +366,83 @@
# translate user-visible url structure to internal structure
args = query.split(r'/', 2)
- if 'cmd' not in req.form and args and args[0]:
+ if 'cmd' not in wsgireq.form and args and args[0]:
cmd = args.pop(0)
style = cmd.rfind('-')
if style != -1:
- req.form['style'] = [cmd[:style]]
+ wsgireq.form['style'] = [cmd[:style]]
cmd = cmd[style + 1:]
# avoid accepting e.g. style parameter as command
if util.safehasattr(webcommands, cmd):
- req.form['cmd'] = [cmd]
+ wsgireq.form['cmd'] = [cmd]
if cmd == 'static':
- req.form['file'] = ['/'.join(args)]
+ wsgireq.form['file'] = ['/'.join(args)]
else:
if args and args[0]:
node = args.pop(0).replace('%2F', '/')
- req.form['node'] = [node]
+ wsgireq.form['node'] = [node]
if args:
- req.form['file'] = args
+ wsgireq.form['file'] = args
- ua = req.env.get('HTTP_USER_AGENT', '')
+ ua = wsgireq.env.get('HTTP_USER_AGENT', '')
if cmd == 'rev' and 'mercurial' in ua:
- req.form['style'] = ['raw']
+ wsgireq.form['style'] = ['raw']
if cmd == 'archive':
- fn = req.form['node'][0]
+ fn = wsgireq.form['node'][0]
for type_, spec in rctx.archivespecs.iteritems():
ext = spec[2]
if fn.endswith(ext):
- req.form['node'] = [fn[:-len(ext)]]
- req.form['type'] = [type_]
+ wsgireq.form['node'] = [fn[:-len(ext)]]
+ wsgireq.form['type'] = [type_]
else:
- cmd = req.form.get('cmd', [''])[0]
+ cmd = wsgireq.form.get('cmd', [''])[0]
# process the web interface request
try:
- tmpl = rctx.templater(req)
+ tmpl = rctx.templater(wsgireq)
ctype = tmpl('mimetype', encoding=encoding.encoding)
ctype = templater.stringify(ctype)
# check read permissions non-static content
if cmd != 'static':
- self.check_perm(rctx, req, None)
+ self.check_perm(rctx, wsgireq, None)
if cmd == '':
- req.form['cmd'] = [tmpl.cache['default']]
- cmd = req.form['cmd'][0]
+ wsgireq.form['cmd'] = [tmpl.cache['default']]
+ cmd = wsgireq.form['cmd'][0]
# Don't enable caching if using a CSP nonce because then it wouldn't
# be a nonce.
if rctx.configbool('web', 'cache') and not rctx.nonce:
- caching(self, req) # sets ETag header or raises NOT_MODIFIED
+ caching(self, wsgireq) # sets ETag header or raises NOT_MODIFIED
if cmd not in webcommands.__all__:
msg = 'no such method: %s' % cmd
raise ErrorResponse(HTTP_BAD_REQUEST, msg)
- elif cmd == 'file' and 'raw' in req.form.get('style', []):
+ elif cmd == 'file' and 'raw' in wsgireq.form.get('style', []):
rctx.ctype = ctype
- content = webcommands.rawfile(rctx, req, tmpl)
+ content = webcommands.rawfile(rctx, wsgireq, tmpl)
else:
- content = getattr(webcommands, cmd)(rctx, req, tmpl)
- req.respond(HTTP_OK, ctype)
+ content = getattr(webcommands, cmd)(rctx, wsgireq, tmpl)
+ wsgireq.respond(HTTP_OK, ctype)
return content
except (error.LookupError, error.RepoLookupError) as err:
- req.respond(HTTP_NOT_FOUND, ctype)
+ wsgireq.respond(HTTP_NOT_FOUND, ctype)
msg = pycompat.bytestr(err)
if (util.safehasattr(err, 'name') and
not isinstance(err, error.ManifestLookupError)):
msg = 'revision not found: %s' % err.name
return tmpl('error', error=msg)
except (error.RepoError, error.RevlogError) as inst:
- req.respond(HTTP_SERVER_ERROR, ctype)
+ wsgireq.respond(HTTP_SERVER_ERROR, ctype)
return tmpl('error', error=pycompat.bytestr(inst))
except ErrorResponse as inst:
- req.respond(inst, ctype)
+ wsgireq.respond(inst, ctype)
if inst.code == HTTP_NOT_MODIFIED:
# Not allowed to return a body on a 304
return ['']