Patchwork D2732: hgweb: rename req to wsgireq

login
register
mail settings
Submitter phabricator
Date March 9, 2018, 7:29 p.m.
Message ID <b016ddbab84d504acc32132a5403ea6f@localhost.localdomain>
Download mbox | patch
Permalink /patch/29188/
State Not Applicable
Headers show

Comments

phabricator - March 9, 2018, 7:29 p.m.
This revision was automatically updated to reflect the committed changes.
Closed by commit rHGb9b968e21f78: hgweb: rename req to wsgireq (authored by indygreg, committed by ).

REPOSITORY
  rHG Mercurial

CHANGES SINCE LAST UPDATE
  https://phab.mercurial-scm.org/D2732?vs=6738&id=6776

REVISION DETAIL
  https://phab.mercurial-scm.org/D2732

AFFECTED FILES
  mercurial/hgweb/hgweb_mod.py
  mercurial/hgweb/hgwebdir_mod.py
  mercurial/wireprotoserver.py

CHANGE DETAILS




To: indygreg, #hg-reviewers, durin42
Cc: mercurial-devel

Patch

diff --git a/mercurial/wireprotoserver.py b/mercurial/wireprotoserver.py
--- a/mercurial/wireprotoserver.py
+++ b/mercurial/wireprotoserver.py
@@ -36,26 +36,26 @@ 
 SSHV1 = wireprototypes.SSHV1
 SSHV2 = wireprototypes.SSHV2
 
-def decodevaluefromheaders(req, headerprefix):
+def decodevaluefromheaders(wsgireq, headerprefix):
     """Decode a long value from multiple HTTP request headers.
 
     Returns the value as a bytes, not a str.
     """
     chunks = []
     i = 1
     prefix = headerprefix.upper().replace(r'-', r'_')
     while True:
-        v = req.env.get(r'HTTP_%s_%d' % (prefix, i))
+        v = wsgireq.env.get(r'HTTP_%s_%d' % (prefix, i))
         if v is None:
             break
         chunks.append(pycompat.bytesurl(v))
         i += 1
 
     return ''.join(chunks)
 
 class httpv1protocolhandler(wireprototypes.baseprotocolhandler):
-    def __init__(self, req, ui, checkperm):
-        self._req = req
+    def __init__(self, wsgireq, ui, checkperm):
+        self._wsgireq = wsgireq
         self._ui = ui
         self._checkperm = checkperm
 
@@ -79,26 +79,26 @@ 
         return [data[k] for k in keys]
 
     def _args(self):
-        args = util.rapply(pycompat.bytesurl, self._req.form.copy())
-        postlen = int(self._req.env.get(r'HTTP_X_HGARGS_POST', 0))
+        args = util.rapply(pycompat.bytesurl, self._wsgireq.form.copy())
+        postlen = int(self._wsgireq.env.get(r'HTTP_X_HGARGS_POST', 0))
         if postlen:
             args.update(urlreq.parseqs(
-                self._req.read(postlen), keep_blank_values=True))
+                self._wsgireq.read(postlen), keep_blank_values=True))
             return args
 
-        argvalue = decodevaluefromheaders(self._req, r'X-HgArg')
+        argvalue = decodevaluefromheaders(self._wsgireq, r'X-HgArg')
         args.update(urlreq.parseqs(argvalue, keep_blank_values=True))
         return args
 
     def forwardpayload(self, fp):
-        if r'HTTP_CONTENT_LENGTH' in self._req.env:
-            length = int(self._req.env[r'HTTP_CONTENT_LENGTH'])
+        if r'HTTP_CONTENT_LENGTH' in self._wsgireq.env:
+            length = int(self._wsgireq.env[r'HTTP_CONTENT_LENGTH'])
         else:
-            length = int(self._req.env[r'CONTENT_LENGTH'])
+            length = int(self._wsgireq.env[r'CONTENT_LENGTH'])
         # If httppostargs is used, we need to read Content-Length
         # minus the amount that was consumed by args.
-        length -= int(self._req.env.get(r'HTTP_X_HGARGS_POST', 0))
-        for s in util.filechunkiter(self._req, limit=length):
+        length -= int(self._wsgireq.env.get(r'HTTP_X_HGARGS_POST', 0))
+        for s in util.filechunkiter(self._wsgireq, limit=length):
             fp.write(s)
 
     @contextlib.contextmanager
@@ -118,9 +118,9 @@ 
 
     def client(self):
         return 'remote:%s:%s:%s' % (
-            self._req.env.get('wsgi.url_scheme') or 'http',
-            urlreq.quote(self._req.env.get('REMOTE_HOST', '')),
-            urlreq.quote(self._req.env.get('REMOTE_USER', '')))
+            self._wsgireq.env.get('wsgi.url_scheme') or 'http',
+            urlreq.quote(self._wsgireq.env.get('REMOTE_HOST', '')),
+            urlreq.quote(self._wsgireq.env.get('REMOTE_USER', '')))
 
     def addcapabilities(self, repo, caps):
         caps.append('httpheader=%d' %
@@ -150,25 +150,25 @@ 
 def iscmd(cmd):
     return cmd in wireproto.commands
 
-def parsehttprequest(rctx, req, query, checkperm):
+def parsehttprequest(rctx, wsgireq, query, checkperm):
     """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.
+    ``wsgireq`` is a ``wsgirequest`` instance.
     """
     repo = rctx.repo
 
     # 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 'cmd' not in req.form:
+    if 'cmd' not in wsgireq.form:
         return None
 
-    cmd = req.form['cmd'][0]
+    cmd = wsgireq.form['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,
@@ -180,24 +180,24 @@ 
     if not iscmd(cmd):
         return None
 
-    proto = httpv1protocolhandler(req, repo.ui,
-                                  lambda perm: checkperm(rctx, req, perm))
+    proto = httpv1protocolhandler(wsgireq, repo.ui,
+                                  lambda perm: checkperm(rctx, wsgireq, perm))
 
     return {
         'cmd': cmd,
         'proto': proto,
-        'dispatch': lambda: _callhttp(repo, req, proto, cmd),
-        'handleerror': lambda ex: _handlehttperror(ex, req, cmd),
+        'dispatch': lambda: _callhttp(repo, wsgireq, proto, cmd),
+        'handleerror': lambda ex: _handlehttperror(ex, wsgireq, cmd),
     }
 
-def _httpresponsetype(ui, req, prefer_uncompressed):
+def _httpresponsetype(ui, wsgireq, prefer_uncompressed):
     """Determine the appropriate response type and compression settings.
 
     Returns a tuple of (mediatype, compengine, engineopts).
     """
     # Determine the response media type and compression engine based
     # on the request parameters.
-    protocaps = decodevaluefromheaders(req, r'X-HgProto').split(' ')
+    protocaps = decodevaluefromheaders(wsgireq, r'X-HgProto').split(' ')
 
     if '0.2' in protocaps:
         # All clients are expected to support uncompressed data.
@@ -230,7 +230,7 @@ 
     opts = {'level': ui.configint('server', 'zliblevel')}
     return HGTYPE, util.compengines['zlib'], opts
 
-def _callhttp(repo, req, proto, cmd):
+def _callhttp(repo, wsgireq, proto, cmd):
     def genversion2(gen, engine, engineopts):
         # application/mercurial-0.2 always sends a payload header
         # identifying the compression engine.
@@ -243,57 +243,57 @@ 
             yield chunk
 
     if not wireproto.commands.commandavailable(cmd, proto):
-        req.respond(HTTP_OK, HGERRTYPE,
-                    body=_('requested wire protocol command is not available '
-                           'over HTTP'))
+        wsgireq.respond(HTTP_OK, HGERRTYPE,
+                        body=_('requested wire protocol command is not '
+                               'available over HTTP'))
         return []
 
     proto.checkperm(wireproto.commands[cmd].permission)
 
     rsp = wireproto.dispatch(repo, proto, cmd)
 
     if isinstance(rsp, bytes):
-        req.respond(HTTP_OK, HGTYPE, body=rsp)
+        wsgireq.respond(HTTP_OK, HGTYPE, body=rsp)
         return []
     elif isinstance(rsp, wireprototypes.bytesresponse):
-        req.respond(HTTP_OK, HGTYPE, body=rsp.data)
+        wsgireq.respond(HTTP_OK, HGTYPE, body=rsp.data)
         return []
     elif isinstance(rsp, wireprototypes.streamreslegacy):
         gen = rsp.gen
-        req.respond(HTTP_OK, HGTYPE)
+        wsgireq.respond(HTTP_OK, HGTYPE)
         return gen
     elif isinstance(rsp, wireprototypes.streamres):
         gen = rsp.gen
 
         # This code for compression should not be streamres specific. It
         # is here because we only compress streamres at the moment.
         mediatype, engine, engineopts = _httpresponsetype(
-            repo.ui, req, rsp.prefer_uncompressed)
+            repo.ui, wsgireq, rsp.prefer_uncompressed)
         gen = engine.compressstream(gen, engineopts)
 
         if mediatype == HGTYPE2:
             gen = genversion2(gen, engine, engineopts)
 
-        req.respond(HTTP_OK, mediatype)
+        wsgireq.respond(HTTP_OK, mediatype)
         return gen
     elif isinstance(rsp, wireprototypes.pushres):
         rsp = '%d\n%s' % (rsp.res, rsp.output)
-        req.respond(HTTP_OK, HGTYPE, body=rsp)
+        wsgireq.respond(HTTP_OK, HGTYPE, body=rsp)
         return []
     elif isinstance(rsp, wireprototypes.pusherr):
         # This is the httplib workaround documented in _handlehttperror().
-        req.drain()
+        wsgireq.drain()
 
         rsp = '0\n%s\n' % rsp.res
-        req.respond(HTTP_OK, HGTYPE, body=rsp)
+        wsgireq.respond(HTTP_OK, HGTYPE, body=rsp)
         return []
     elif isinstance(rsp, wireprototypes.ooberror):
         rsp = rsp.message
-        req.respond(HTTP_OK, HGERRTYPE, body=rsp)
+        wsgireq.respond(HTTP_OK, HGERRTYPE, body=rsp)
         return []
     raise error.ProgrammingError('hgweb.protocol internal failure', rsp)
 
-def _handlehttperror(e, req, cmd):
+def _handlehttperror(e, wsgireq, cmd):
     """Called when an ErrorResponse is raised during HTTP request processing."""
 
     # Clients using Python's httplib are stateful: the HTTP client
@@ -304,20 +304,20 @@ 
     # the HTTP response. In other words, it helps prevent deadlocks
     # on clients using httplib.
 
-    if (req.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.
-        (req.env.get('HTTP_EXPECT',
-                     '').lower() != '100-continue') or
+        (wsgireq.env.get('HTTP_EXPECT',
+                         '').lower() != '100-continue') or
         # Or the non-httplib HTTP library is being advertised by
         # the client.
-        req.env.get('X-HgHttp2', '')):
-        req.drain()
+        wsgireq.env.get('X-HgHttp2', '')):
+        wsgireq.drain()
     else:
-        req.headers.append((r'Connection', r'Close'))
+        wsgireq.headers.append((r'Connection', r'Close'))
 
     # TODO This response body assumes the failed command was
     # "unbundle." That assumption is not always valid.
-    req.respond(e, HGTYPE, body='0\n%s\n' % pycompat.bytestr(e))
+    wsgireq.respond(e, HGTYPE, body='0\n%s\n' % pycompat.bytestr(e))
 
     return ''
 
diff --git a/mercurial/hgweb/hgwebdir_mod.py b/mercurial/hgweb/hgwebdir_mod.py
--- a/mercurial/hgweb/hgwebdir_mod.py
+++ b/mercurial/hgweb/hgwebdir_mod.py
@@ -26,7 +26,6 @@ 
     paritygen,
     staticfile,
 )
-from .request import wsgirequest
 
 from .. import (
     configitems,
@@ -43,6 +42,7 @@ 
 
 from . import (
     hgweb_mod,
+    request as requestmod,
     webutil,
     wsgicgi,
 )
@@ -197,19 +197,19 @@ 
         wsgicgi.launch(self)
 
     def __call__(self, env, respond):
-        req = wsgirequest(env, respond)
-        return self.run_wsgi(req)
+        wsgireq = requestmod.wsgirequest(env, respond)
+        return self.run_wsgi(wsgireq)
 
-    def read_allowed(self, ui, req):
+    def read_allowed(self, ui, wsgireq):
         """Check allow_read and deny_read config options of a repo's ui object
         to determine user permissions.  By default, with neither option set (or
         both empty), allow all users to read the repo.  There are two ways a
         user can be denied read access:  (1) deny_read is not empty, and the
         user is unauthenticated or deny_read contains user (or *), and (2)
         allow_read is not empty and the user is not in allow_read.  Return True
         if user is allowed to read the repo, else return False."""
 
-        user = req.env.get('REMOTE_USER')
+        user = wsgireq.env.get('REMOTE_USER')
 
         deny_read = ui.configlist('web', 'deny_read', untrusted=True)
         if deny_read and (not user or ismember(ui, user, deny_read)):
@@ -222,56 +222,56 @@ 
 
         return False
 
-    def run_wsgi(self, req):
+    def run_wsgi(self, wsgireq):
         profile = self.ui.configbool('profiling', 'enabled')
         with profiling.profile(self.ui, enabled=profile):
-            for r in self._runwsgi(req):
+            for r in self._runwsgi(wsgireq):
                 yield r
 
-    def _runwsgi(self, req):
+    def _runwsgi(self, wsgireq):
         try:
             self.refresh()
 
             csp, nonce = cspvalues(self.ui)
             if csp:
-                req.headers.append(('Content-Security-Policy', csp))
+                wsgireq.headers.append(('Content-Security-Policy', csp))
 
-            virtual = req.env.get("PATH_INFO", "").strip('/')
-            tmpl = self.templater(req, nonce)
+            virtual = wsgireq.env.get("PATH_INFO", "").strip('/')
+            tmpl = self.templater(wsgireq, nonce)
             ctype = tmpl('mimetype', encoding=encoding.encoding)
             ctype = templater.stringify(ctype)
 
             # a static file
-            if virtual.startswith('static/') or 'static' in req.form:
+            if virtual.startswith('static/') or 'static' in wsgireq.form:
                 if virtual.startswith('static/'):
                     fname = virtual[7:]
                 else:
-                    fname = req.form['static'][0]
+                    fname = wsgireq.form['static'][0]
                 static = self.ui.config("web", "static", None,
                                         untrusted=False)
                 if not static:
                     tp = self.templatepath or templater.templatepaths()
                     if isinstance(tp, str):
                         tp = [tp]
                     static = [os.path.join(p, 'static') for p in tp]
-                staticfile(static, fname, req)
+                staticfile(static, fname, wsgireq)
                 return []
 
             # top-level index
 
             repos = dict(self.repos)
 
             if (not virtual or virtual == 'index') and virtual not in repos:
-                req.respond(HTTP_OK, ctype)
-                return self.makeindex(req, tmpl)
+                wsgireq.respond(HTTP_OK, ctype)
+                return self.makeindex(wsgireq, tmpl)
 
             # nested indexes and hgwebs
 
             if virtual.endswith('/index') and virtual not in repos:
                 subdir = virtual[:-len('index')]
                 if any(r.startswith(subdir) for r in repos):
-                    req.respond(HTTP_OK, ctype)
-                    return self.makeindex(req, tmpl, subdir)
+                    wsgireq.respond(HTTP_OK, ctype)
+                    return self.makeindex(wsgireq, tmpl, subdir)
 
             def _virtualdirs():
                 # Check the full virtual path, each parent, and the root ('')
@@ -286,11 +286,11 @@ 
             for virtualrepo in _virtualdirs():
                 real = repos.get(virtualrepo)
                 if real:
-                    req.env['REPO_NAME'] = virtualrepo
+                    wsgireq.env['REPO_NAME'] = virtualrepo
                     try:
                         # ensure caller gets private copy of ui
                         repo = hg.repository(self.ui.copy(), real)
-                        return hgweb_mod.hgweb(repo).run_wsgi(req)
+                        return hgweb_mod.hgweb(repo).run_wsgi(wsgireq)
                     except IOError as inst:
                         msg = encoding.strtolocal(inst.strerror)
                         raise ErrorResponse(HTTP_SERVER_ERROR, msg)
@@ -300,20 +300,20 @@ 
             # browse subdirectories
             subdir = virtual + '/'
             if [r for r in repos if r.startswith(subdir)]:
-                req.respond(HTTP_OK, ctype)
-                return self.makeindex(req, tmpl, subdir)
+                wsgireq.respond(HTTP_OK, ctype)
+                return self.makeindex(wsgireq, tmpl, subdir)
 
             # prefixes not found
-            req.respond(HTTP_NOT_FOUND, ctype)
+            wsgireq.respond(HTTP_NOT_FOUND, ctype)
             return tmpl("notfound", repo=virtual)
 
         except ErrorResponse as err:
-            req.respond(err, ctype)
+            wsgireq.respond(err, ctype)
             return tmpl('error', error=err.message or '')
         finally:
             tmpl = None
 
-    def makeindex(self, req, tmpl, subdir=""):
+    def makeindex(self, wsgireq, tmpl, subdir=""):
 
         def archivelist(ui, nodeid, url):
             allowed = ui.configlist("web", "allow_archive", untrusted=True)
@@ -369,8 +369,8 @@ 
 
                 parts = [name]
                 parts.insert(0, '/' + subdir.rstrip('/'))
-                if req.env['SCRIPT_NAME']:
-                    parts.insert(0, req.env['SCRIPT_NAME'])
+                if wsgireq.env['SCRIPT_NAME']:
+                    parts.insert(0, wsgireq.env['SCRIPT_NAME'])
                 url = re.sub(r'/+', '/', '/'.join(parts) + '/')
 
                 # show either a directory entry or a repository
@@ -413,7 +413,7 @@ 
                 if u.configbool("web", "hidden", untrusted=True):
                     continue
 
-                if not self.read_allowed(u, req):
+                if not self.read_allowed(u, wsgireq):
                     continue
 
                 # update time with local timezone
@@ -465,8 +465,8 @@ 
         self.refresh()
         sortable = ["name", "description", "contact", "lastchange"]
         sortcolumn, descending = sortdefault
-        if 'sort' in req.form:
-            sortcolumn = req.form['sort'][0]
+        if 'sort' in wsgireq.form:
+            sortcolumn = wsgireq.form['sort'][0]
             descending = sortcolumn.startswith('-')
             if descending:
                 sortcolumn = sortcolumn[1:]
@@ -479,14 +479,14 @@ 
                 for column in sortable]
 
         self.refresh()
-        self.updatereqenv(req.env)
+        self.updatereqenv(wsgireq.env)
 
         return tmpl("index", entries=entries, subdir=subdir,
                     pathdef=hgweb_mod.makebreadcrumb('/' + subdir, self.prefix),
                     sortcolumn=sortcolumn, descending=descending,
                     **dict(sort))
 
-    def templater(self, req, nonce):
+    def templater(self, wsgireq, nonce):
 
         def motd(**map):
             if self.motd is not None:
@@ -497,14 +497,14 @@ 
         def config(section, name, default=uimod._unset, untrusted=True):
             return self.ui.config(section, name, default, untrusted)
 
-        self.updatereqenv(req.env)
+        self.updatereqenv(wsgireq.env)
 
-        url = req.env.get('SCRIPT_NAME', '')
+        url = wsgireq.env.get('SCRIPT_NAME', '')
         if not url.endswith('/'):
             url += '/'
 
         vars = {}
-        styles, (style, mapfile) = hgweb_mod.getstyle(req, config,
+        styles, (style, mapfile) = hgweb_mod.getstyle(wsgireq, config,
                                                       self.templatepath)
         if style == styles[0]:
             vars['style'] = style
diff --git a/mercurial/hgweb/hgweb_mod.py b/mercurial/hgweb/hgweb_mod.py
--- a/mercurial/hgweb/hgweb_mod.py
+++ b/mercurial/hgweb/hgweb_mod.py
@@ -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,25 +142,25 @@ 
             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'
         else:
             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,35 +172,35 @@ 
         # 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)
 
         # 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,
             'urlbase': urlbase,
             'repo': self.reponame,
             '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,57 +301,57 @@ 
 
         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
         should be using instances of this class as the WSGI application.
         """
         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 ['']