This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2732

hgweb: rename req to wsgireq
ClosedPublic

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

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHGb9b968e21f78: hgweb: rename req to wsgireq
Summary

We will soon introduce a parsed WSGI request object so we don't
have to concern ourselves with low-level WSGI matters. Prepare
for multiple request objects by renaming the existing one so it
is clear it deals with WSGI.

We also remove a symbol import to avoid even more naming confusion.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

indygreg created this revision.Mar 8 2018, 8:06 PM
durin42 accepted this revision.Mar 9 2018, 1:56 PM
This revision is now accepted and ready to land.Mar 9 2018, 1:56 PM
Closed by commit rHGb9b968e21f78: hgweb: rename req to wsgireq (authored by indygreg). · Explain WhyMar 9 2018, 2:29 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 6738

mercurial/hgweb/hgweb_mod.py

HTTP_NOT_FOUND, HTTP_NOT_FOUND,
HTTP_NOT_MODIFIED, HTTP_NOT_MODIFIED,
HTTP_OK, HTTP_OK,
HTTP_SERVER_ERROR, HTTP_SERVER_ERROR,
caching, caching,
cspvalues, cspvalues,
permhooks, permhooks,
) )
from .request import wsgirequest
from .. import ( from .. import (
encoding, encoding,
error, error,
formatter, formatter,
hg, hg,
hook, hook,
profiling, profiling,
pycompat, pycompat,
repoview, repoview,
templatefilters, templatefilters,
templater, templater,
ui as uimod, ui as uimod,
util, util,
wireprotoserver, wireprotoserver,
) )
from . import ( from . import (
request as requestmod,
webcommands, webcommands,
webutil, webutil,
wsgicgi, wsgicgi,
) )
archivespecs = util.sortdict(( archivespecs = util.sortdict((
('zip', ('application/zip', 'zip', '.zip', None)), ('zip', ('application/zip', 'zip', '.zip', None)),
('gz', ('application/x-gzip', 'tgz', '.tar.gz', None)), ('gz', ('application/x-gzip', 'tgz', '.tar.gz', None)),
untrusted=untrusted) untrusted=untrusted)
def archivelist(self, nodeid): def archivelist(self, nodeid):
allowed = self.configlist('web', 'allow_archive') allowed = self.configlist('web', 'allow_archive')
for typ, spec in self.archivespecs.iteritems(): for typ, spec in self.archivespecs.iteritems():
if typ in allowed or self.configbool('web', 'allow%s' % typ): if typ in allowed or self.configbool('web', 'allow%s' % typ):
yield {'type': typ, 'extension': spec[2], 'node': nodeid} yield {'type': typ, 'extension': spec[2], 'node': nodeid}
def templater(self, req): def templater(self, wsgireq):
# determine scheme, port and server name # determine scheme, port and server name
# this is needed to create absolute urls # this is needed to create absolute urls
proto = req.env.get('wsgi.url_scheme') proto = wsgireq.env.get('wsgi.url_scheme')
if proto == 'https': if proto == 'https':
proto = 'https' proto = 'https'
default_port = '443' default_port = '443'
else: else:
proto = 'http' proto = 'http'
default_port = '80' default_port = '80'
port = req.env[r'SERVER_PORT'] port = wsgireq.env[r'SERVER_PORT']
port = port != default_port and (r':' + port) or r'' 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') logourl = self.config('web', 'logourl')
logoimg = self.config('web', 'logoimg') logoimg = self.config('web', 'logoimg')
staticurl = (self.config('web', 'staticurl') staticurl = (self.config('web', 'staticurl')
or pycompat.sysbytes(req.url) + 'static/') or pycompat.sysbytes(wsgireq.url) + 'static/')
if not staticurl.endswith('/'): if not staticurl.endswith('/'):
staticurl += '/' staticurl += '/'
# some functions for the templater # some functions for the templater
def motd(**map): def motd(**map):
yield self.config('web', 'motd') yield self.config('web', 'motd')
# figure out which style to use # figure out which style to use
vars = {} vars = {}
styles, (style, mapfile) = getstyle(req, self.config, styles, (style, mapfile) = getstyle(wsgireq, self.config,
self.templatepath) self.templatepath)
if style == styles[0]: if style == styles[0]:
vars['style'] = style vars['style'] = style
start = '&' if req.url[-1] == r'?' else '?' start = '&' if wsgireq.url[-1] == r'?' else '?'
sessionvars = webutil.sessionvars(vars, start) sessionvars = webutil.sessionvars(vars, start)
if not self.reponame: if not self.reponame:
self.reponame = (self.config('web', 'name', '') self.reponame = (self.config('web', 'name', '')
or req.env.get('REPO_NAME') or wsgireq.env.get('REPO_NAME')
or req.url.strip(r'/') or self.repo.root) or wsgireq.url.strip(r'/') or self.repo.root)
def websubfilter(text): def websubfilter(text):
return templatefilters.websub(text, self.websubtable) return templatefilters.websub(text, self.websubtable)
# create the templater # create the templater
# TODO: export all keywords: defaults = templatekw.keywords.copy() # TODO: export all keywords: defaults = templatekw.keywords.copy()
defaults = { defaults = {
'url': pycompat.sysbytes(req.url), 'url': pycompat.sysbytes(wsgireq.url),
'logourl': logourl, 'logourl': logourl,
'logoimg': logoimg, 'logoimg': logoimg,
'staticurl': staticurl, 'staticurl': staticurl,
'urlbase': urlbase, 'urlbase': urlbase,
'repo': self.reponame, 'repo': self.reponame,
'encoding': encoding.encoding, 'encoding': encoding.encoding,
'motd': motd, 'motd': motd,
'sessionvars': sessionvars, 'sessionvars': sessionvars,
'pathdef': makebreadcrumb(pycompat.sysbytes(req.url)), 'pathdef': makebreadcrumb(pycompat.sysbytes(wsgireq.url)),
'style': style, 'style': style,
'nonce': self.nonce, 'nonce': self.nonce,
} }
tres = formatter.templateresources(self.repo.ui, self.repo) tres = formatter.templateresources(self.repo.ui, self.repo)
tmpl = templater.templater.frommapfile(mapfile, tmpl = templater.templater.frommapfile(mapfile,
filters={'websub': websubfilter}, filters={'websub': websubfilter},
defaults=defaults, defaults=defaults,
resources=tres) resources=tres)
"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 = wsgirequest(env, respond) req = requestmod.wsgirequest(env, respond)
return self.run_wsgi(req) return self.run_wsgi(req)
def run_wsgi(self, req): def run_wsgi(self, wsgireq):
"""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(req, repo): for r in self._runwsgi(wsgireq, repo):
yield r yield r
def _runwsgi(self, req, repo): def _runwsgi(self, wsgireq, repo):
rctx = requestcontext(self, repo) rctx = requestcontext(self, repo)
# 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.env rctx.repo.ui.environ = wsgireq.env
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,
# replace it. # replace it.
req.headers = [h for h in req.headers wsgireq.headers = [h for h in wsgireq.headers
if h[0] != 'Content-Security-Policy'] if h[0] != 'Content-Security-Policy']
req.headers.append(('Content-Security-Policy', rctx.csp)) wsgireq.headers.append(('Content-Security-Policy', rctx.csp))
# work with CGI variables to create coherent structure # work with CGI variables to create coherent structure
# use SCRIPT_NAME, PATH_INFO and QUERY_STRING as well as our REPO_NAME # use SCRIPT_NAME, PATH_INFO and QUERY_STRING as well as our REPO_NAME
req.url = req.env[r'SCRIPT_NAME'] wsgireq.url = wsgireq.env[r'SCRIPT_NAME']
if not req.url.endswith(r'/'): if not wsgireq.url.endswith(r'/'):
req.url += r'/' wsgireq.url += r'/'
if req.env.get('REPO_NAME'): if wsgireq.env.get('REPO_NAME'):
req.url += req.env[r'REPO_NAME'] + r'/' wsgireq.url += wsgireq.env[r'REPO_NAME'] + r'/'
if r'PATH_INFO' in req.env: if r'PATH_INFO' in wsgireq.env:
parts = req.env[r'PATH_INFO'].strip(r'/').split(r'/') parts = wsgireq.env[r'PATH_INFO'].strip(r'/').split(r'/')
repo_parts = req.env.get(r'REPO_NAME', r'').split(r'/') repo_parts = wsgireq.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 = r'/'.join(parts) query = r'/'.join(parts)
else: else:
query = req.env[r'QUERY_STRING'].partition(r'&')[0] query = wsgireq.env[r'QUERY_STRING'].partition(r'&')[0]
query = query.partition(r';')[0] query = query.partition(r';')[0]
# Route it to a wire protocol handler if it looks like a wire protocol # Route it to a wire protocol handler if it looks like a wire protocol
# request. # request.
protohandler = wireprotoserver.parsehttprequest(rctx, req, query, protohandler = wireprotoserver.parsehttprequest(rctx, wsgireq, query,
self.check_perm) self.check_perm)
if protohandler: if protohandler:
try: try:
if query: if query:
raise ErrorResponse(HTTP_NOT_FOUND) raise ErrorResponse(HTTP_NOT_FOUND)
return protohandler['dispatch']() return protohandler['dispatch']()
except ErrorResponse as inst: except ErrorResponse as inst:
return protohandler['handleerror'](inst) return protohandler['handleerror'](inst)
# translate user-visible url structure to internal structure # translate user-visible url structure to internal structure
args = query.split(r'/', 2) 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) cmd = args.pop(0)
style = cmd.rfind('-') style = cmd.rfind('-')
if style != -1: if style != -1:
req.form['style'] = [cmd[:style]] wsgireq.form['style'] = [cmd[:style]]
cmd = cmd[style + 1:] cmd = cmd[style + 1:]
# avoid accepting e.g. style parameter as command # avoid accepting e.g. style parameter as command
if util.safehasattr(webcommands, cmd): if util.safehasattr(webcommands, cmd):
req.form['cmd'] = [cmd] wsgireq.form['cmd'] = [cmd]
if cmd == 'static': if cmd == 'static':
req.form['file'] = ['/'.join(args)] wsgireq.form['file'] = ['/'.join(args)]
else: else:
if args and args[0]: if args and args[0]:
node = args.pop(0).replace('%2F', '/') node = args.pop(0).replace('%2F', '/')
req.form['node'] = [node] wsgireq.form['node'] = [node]
if args: 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: if cmd == 'rev' and 'mercurial' in ua:
req.form['style'] = ['raw'] wsgireq.form['style'] = ['raw']
if cmd == 'archive': if cmd == 'archive':
fn = req.form['node'][0] fn = wsgireq.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)]] wsgireq.form['node'] = [fn[:-len(ext)]]
req.form['type'] = [type_] wsgireq.form['type'] = [type_]
else: else:
cmd = req.form.get('cmd', [''])[0] cmd = wsgireq.form.get('cmd', [''])[0]
# process the web interface request # process the web interface request
try: try:
tmpl = rctx.templater(req) tmpl = rctx.templater(wsgireq)
ctype = tmpl('mimetype', encoding=encoding.encoding) ctype = tmpl('mimetype', encoding=encoding.encoding)
ctype = templater.stringify(ctype) ctype = templater.stringify(ctype)
# check read permissions non-static content # check read permissions non-static content
if cmd != 'static': if cmd != 'static':
self.check_perm(rctx, req, None) self.check_perm(rctx, wsgireq, None)
if cmd == '': if cmd == '':
req.form['cmd'] = [tmpl.cache['default']] wsgireq.form['cmd'] = [tmpl.cache['default']]
cmd = req.form['cmd'][0] cmd = wsgireq.form['cmd'][0]
# Don't enable caching if using a CSP nonce because then it wouldn't # Don't enable caching if using a CSP nonce because then it wouldn't
# be a nonce. # be a nonce.
if rctx.configbool('web', 'cache') and not rctx.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__: if cmd not in webcommands.__all__:
msg = 'no such method: %s' % cmd msg = 'no such method: %s' % cmd
raise ErrorResponse(HTTP_BAD_REQUEST, msg) 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 rctx.ctype = ctype
content = webcommands.rawfile(rctx, req, tmpl) content = webcommands.rawfile(rctx, wsgireq, tmpl)
else: else:
content = getattr(webcommands, cmd)(rctx, req, tmpl) content = getattr(webcommands, cmd)(rctx, wsgireq, tmpl)
req.respond(HTTP_OK, ctype) wsgireq.respond(HTTP_OK, ctype)
return content return content
except (error.LookupError, error.RepoLookupError) as err: except (error.LookupError, error.RepoLookupError) as err:
req.respond(HTTP_NOT_FOUND, ctype) wsgireq.respond(HTTP_NOT_FOUND, ctype)
msg = pycompat.bytestr(err) msg = pycompat.bytestr(err)
if (util.safehasattr(err, 'name') and if (util.safehasattr(err, 'name') and
not isinstance(err, error.ManifestLookupError)): not isinstance(err, error.ManifestLookupError)):
msg = 'revision not found: %s' % err.name msg = 'revision not found: %s' % err.name
return tmpl('error', error=msg) return tmpl('error', error=msg)
except (error.RepoError, error.RevlogError) as inst: 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)) return tmpl('error', error=pycompat.bytestr(inst))
except ErrorResponse as inst: except ErrorResponse as inst:
req.respond(inst, ctype) wsgireq.respond(inst, ctype)
if inst.code == HTTP_NOT_MODIFIED: if inst.code == HTTP_NOT_MODIFIED:
# Not allowed to return a body on a 304 # Not allowed to return a body on a 304
return [''] return ['']
return tmpl('error', error=pycompat.bytestr(inst)) return tmpl('error', error=pycompat.bytestr(inst))
def check_perm(self, rctx, req, op): def check_perm(self, rctx, req, op):
for permhook in permhooks: for permhook in permhooks:
permhook(rctx, req, op) permhook(rctx, req, op)

mercurial/hgweb/hgwebdir_mod.py

HTTP_SERVER_ERROR, HTTP_SERVER_ERROR,
cspvalues, cspvalues,
get_contact, get_contact,
get_mtime, get_mtime,
ismember, ismember,
paritygen, paritygen,
staticfile, staticfile,
) )
from .request import wsgirequest
from .. import ( from .. import (
configitems, configitems,
encoding, encoding,
error, error,
hg, hg,
profiling, profiling,
pycompat, pycompat,
scmutil, scmutil,
templater, templater,
ui as uimod, ui as uimod,
util, util,
) )
from . import ( from . import (
hgweb_mod, hgweb_mod,
request as requestmod,
webutil, webutil,
wsgicgi, wsgicgi,
) )
from ..utils import dateutil from ..utils import dateutil
def cleannames(items): def cleannames(items):
return [(util.pconvert(name).strip('/'), path) for name, path in items] return [(util.pconvert(name).strip('/'), path) for name, path in items]
def run(self): def run(self):
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):
req = wsgirequest(env, respond) wsgireq = requestmod.wsgirequest(env, respond)
return self.run_wsgi(req) 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 """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 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 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 can be denied read access: (1) deny_read is not empty, and the
user is unauthenticated or deny_read contains user (or *), and (2) 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 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.""" 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) deny_read = ui.configlist('web', 'deny_read', untrusted=True)
if deny_read and (not user or ismember(ui, user, deny_read)): if deny_read and (not user or ismember(ui, user, deny_read)):
return False return False
allow_read = ui.configlist('web', 'allow_read', untrusted=True) allow_read = ui.configlist('web', 'allow_read', untrusted=True)
# by default, allow reading if no allow_read option has been set # by default, allow reading if no allow_read option has been set
if (not allow_read) or ismember(ui, user, allow_read): if (not allow_read) or ismember(ui, user, allow_read):
return True return True
return False return False
def run_wsgi(self, req): def run_wsgi(self, wsgireq):
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(req): for r in self._runwsgi(wsgireq):
yield r yield r
def _runwsgi(self, req): def _runwsgi(self, wsgireq):
try: try:
self.refresh() self.refresh()
csp, nonce = cspvalues(self.ui) csp, nonce = cspvalues(self.ui)
if csp: if csp:
req.headers.append(('Content-Security-Policy', csp)) wsgireq.headers.append(('Content-Security-Policy', csp))
virtual = req.env.get("PATH_INFO", "").strip('/') virtual = wsgireq.env.get("PATH_INFO", "").strip('/')
tmpl = self.templater(req, nonce) tmpl = self.templater(wsgireq, nonce)
ctype = tmpl('mimetype', encoding=encoding.encoding) ctype = tmpl('mimetype', encoding=encoding.encoding)
ctype = templater.stringify(ctype) ctype = templater.stringify(ctype)
# a static file # 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/'): if virtual.startswith('static/'):
fname = virtual[7:] fname = virtual[7:]
else: else:
fname = req.form['static'][0] fname = wsgireq.form['static'][0]
static = self.ui.config("web", "static", None, static = self.ui.config("web", "static", None,
untrusted=False) untrusted=False)
if not static: if not static:
tp = self.templatepath or templater.templatepaths() tp = self.templatepath or templater.templatepaths()
if isinstance(tp, str): if isinstance(tp, str):
tp = [tp] tp = [tp]
static = [os.path.join(p, 'static') for p in tp] static = [os.path.join(p, 'static') for p in tp]
staticfile(static, fname, req) staticfile(static, fname, wsgireq)
return [] return []
# top-level index # top-level index
repos = dict(self.repos) repos = dict(self.repos)
if (not virtual or virtual == 'index') and virtual not in repos: if (not virtual or virtual == 'index') and virtual not in repos:
req.respond(HTTP_OK, ctype) wsgireq.respond(HTTP_OK, ctype)
return self.makeindex(req, tmpl) return self.makeindex(wsgireq, tmpl)
# nested indexes and hgwebs # nested indexes and hgwebs
if virtual.endswith('/index') and virtual not in repos: if virtual.endswith('/index') and virtual not in repos:
subdir = virtual[:-len('index')] subdir = virtual[:-len('index')]
if any(r.startswith(subdir) for r in repos): if any(r.startswith(subdir) for r in repos):
req.respond(HTTP_OK, ctype) wsgireq.respond(HTTP_OK, ctype)
return self.makeindex(req, tmpl, subdir) return self.makeindex(wsgireq, tmpl, subdir)
def _virtualdirs(): def _virtualdirs():
# Check the full virtual path, each parent, and the root ('') # Check the full virtual path, each parent, and the root ('')
if virtual != '': if virtual != '':
yield virtual yield virtual
for p in util.finddirs(virtual): for p in util.finddirs(virtual):
yield p yield p
yield '' yield ''
for virtualrepo in _virtualdirs(): for virtualrepo in _virtualdirs():
real = repos.get(virtualrepo) real = repos.get(virtualrepo)
if real: if real:
req.env['REPO_NAME'] = virtualrepo wsgireq.env['REPO_NAME'] = virtualrepo
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(req) return hgweb_mod.hgweb(repo).run_wsgi(wsgireq)
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 + '/'
if [r for r in repos if r.startswith(subdir)]: if [r for r in repos if r.startswith(subdir)]:
req.respond(HTTP_OK, ctype) wsgireq.respond(HTTP_OK, ctype)
return self.makeindex(req, tmpl, subdir) return self.makeindex(wsgireq, tmpl, subdir)
# prefixes not found # prefixes not found
req.respond(HTTP_NOT_FOUND, ctype) wsgireq.respond(HTTP_NOT_FOUND, ctype)
return tmpl("notfound", repo=virtual) return tmpl("notfound", repo=virtual)
except ErrorResponse as err: except ErrorResponse as err:
req.respond(err, ctype) wsgireq.respond(err, ctype)
return tmpl('error', error=err.message or '') return tmpl('error', error=err.message or '')
finally: finally:
tmpl = None tmpl = None
def makeindex(self, req, tmpl, subdir=""): def makeindex(self, wsgireq, tmpl, subdir=""):
def archivelist(ui, nodeid, url): def archivelist(ui, nodeid, url):
allowed = ui.configlist("web", "allow_archive", untrusted=True) allowed = ui.configlist("web", "allow_archive", untrusted=True)
archives = [] archives = []
for typ, spec in hgweb_mod.archivespecs.iteritems(): for typ, spec in hgweb_mod.archivespecs.iteritems():
if typ in allowed or ui.configbool("web", "allow" + typ, if typ in allowed or ui.configbool("web", "allow" + typ,
untrusted=True): untrusted=True):
archives.append({"type": typ, "extension": spec[2], archives.append({"type": typ, "extension": spec[2],
try: try:
r = hg.repository(self.ui, path) r = hg.repository(self.ui, path)
directory = False directory = False
except (IOError, error.RepoError): except (IOError, error.RepoError):
pass pass
parts = [name] parts = [name]
parts.insert(0, '/' + subdir.rstrip('/')) parts.insert(0, '/' + subdir.rstrip('/'))
if req.env['SCRIPT_NAME']: if wsgireq.env['SCRIPT_NAME']:
parts.insert(0, req.env['SCRIPT_NAME']) parts.insert(0, wsgireq.env['SCRIPT_NAME'])
url = re.sub(r'/+', '/', '/'.join(parts) + '/') url = re.sub(r'/+', '/', '/'.join(parts) + '/')
# show either a directory entry or a repository # show either a directory entry or a repository
if directory: if directory:
# get the directory's time information # get the directory's time information
try: try:
d = (get_mtime(path), dateutil.makedate()[1]) d = (get_mtime(path), dateutil.makedate()[1])
except OSError: except OSError:
u.warn(_('error reading %s/.hg/hgrc: %s\n') % (path, e)) u.warn(_('error reading %s/.hg/hgrc: %s\n') % (path, e))
continue continue
def get(section, name, default=uimod._unset): def get(section, name, default=uimod._unset):
return u.config(section, name, default, untrusted=True) return u.config(section, name, default, untrusted=True)
if u.configbool("web", "hidden", untrusted=True): if u.configbool("web", "hidden", untrusted=True):
continue continue
if not self.read_allowed(u, req): if not self.read_allowed(u, wsgireq):
continue continue
# update time with local timezone # update time with local timezone
try: try:
r = hg.repository(self.ui, path) r = hg.repository(self.ui, path)
except IOError: except IOError:
u.warn(_('error accessing repository at %s\n') % path) u.warn(_('error accessing repository at %s\n') % path)
continue continue
reverse=descending) reverse=descending)
for row, parity in zip(rows, paritygen(self.stripecount)): for row, parity in zip(rows, paritygen(self.stripecount)):
row['parity'] = parity row['parity'] = parity
yield row yield row
self.refresh() self.refresh()
sortable = ["name", "description", "contact", "lastchange"] sortable = ["name", "description", "contact", "lastchange"]
sortcolumn, descending = sortdefault sortcolumn, descending = sortdefault
if 'sort' in req.form: if 'sort' in wsgireq.form:
sortcolumn = req.form['sort'][0] sortcolumn = wsgireq.form['sort'][0]
descending = sortcolumn.startswith('-') descending = sortcolumn.startswith('-')
if descending: if descending:
sortcolumn = sortcolumn[1:] sortcolumn = sortcolumn[1:]
if sortcolumn not in sortable: if sortcolumn not in sortable:
sortcolumn = "" sortcolumn = ""
sort = [("sort_%s" % column, sort = [("sort_%s" % column,
"%s%s" % ((not descending and column == sortcolumn) "%s%s" % ((not descending and column == sortcolumn)
and "-" or "", column)) and "-" or "", column))
for column in sortable] for column in sortable]
self.refresh() self.refresh()
self.updatereqenv(req.env) self.updatereqenv(wsgireq.env)
return tmpl("index", entries=entries, subdir=subdir, return tmpl("index", entries=entries, subdir=subdir,
pathdef=hgweb_mod.makebreadcrumb('/' + subdir, self.prefix), pathdef=hgweb_mod.makebreadcrumb('/' + subdir, self.prefix),
sortcolumn=sortcolumn, descending=descending, sortcolumn=sortcolumn, descending=descending,
**dict(sort)) **dict(sort))
def templater(self, req, nonce): def templater(self, wsgireq, nonce):
def motd(**map): def motd(**map):
if self.motd is not None: if self.motd is not None:
yield self.motd yield self.motd
else: else:
yield config('web', 'motd') yield config('web', 'motd')
def config(section, name, default=uimod._unset, untrusted=True): def config(section, name, default=uimod._unset, untrusted=True):
return self.ui.config(section, name, default, untrusted) 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('/'): if not url.endswith('/'):
url += '/' url += '/'
vars = {} vars = {}
styles, (style, mapfile) = hgweb_mod.getstyle(req, config, styles, (style, mapfile) = hgweb_mod.getstyle(wsgireq, config,
self.templatepath) self.templatepath)
if style == styles[0]: if style == styles[0]:
vars['style'] = style vars['style'] = style
start = r'&' if url[-1] == r'?' else r'?' start = r'&' if url[-1] == r'?' else r'?'
sessionvars = webutil.sessionvars(vars, start) sessionvars = webutil.sessionvars(vars, start)
logourl = config('web', 'logourl') logourl = config('web', 'logourl')
logoimg = config('web', 'logoimg') logoimg = config('web', 'logoimg')

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(req, headerprefix): def decodevaluefromheaders(wsgireq, 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'_') prefix = headerprefix.upper().replace(r'-', r'_')
while True: 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: 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, req, ui, checkperm): def __init__(self, wsgireq, ui, checkperm):
self._req = req self._wsgireq = wsgireq
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._req.form.copy()) args = util.rapply(pycompat.bytesurl, self._wsgireq.form.copy())
postlen = int(self._req.env.get(r'HTTP_X_HGARGS_POST', 0)) postlen = int(self._wsgireq.env.get(r'HTTP_X_HGARGS_POST', 0))
if postlen: if postlen:
args.update(urlreq.parseqs( args.update(urlreq.parseqs(
self._req.read(postlen), keep_blank_values=True)) self._wsgireq.read(postlen), keep_blank_values=True))
return args 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)) 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._req.env: if r'HTTP_CONTENT_LENGTH' in self._wsgireq.env:
length = int(self._req.env[r'HTTP_CONTENT_LENGTH']) length = int(self._wsgireq.env[r'HTTP_CONTENT_LENGTH'])
else: 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 # 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._req.env.get(r'HTTP_X_HGARGS_POST', 0)) length -= int(self._wsgireq.env.get(r'HTTP_X_HGARGS_POST', 0))
for s in util.filechunkiter(self._req, 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
out = util.stringio() out = util.stringio()
try: try:
self._ui.fout = out self._ui.fout = out
self._ui.ferr = out self._ui.ferr = out
yield out yield out
finally: finally:
self._ui.fout = oldout self._ui.fout = oldout
self._ui.ferr = olderr self._ui.ferr = olderr
def client(self): def client(self):
return 'remote:%s:%s:%s' % ( return 'remote:%s:%s:%s' % (
self._req.env.get('wsgi.url_scheme') or 'http', self._wsgireq.env.get('wsgi.url_scheme') or 'http',
urlreq.quote(self._req.env.get('REMOTE_HOST', '')), urlreq.quote(self._wsgireq.env.get('REMOTE_HOST', '')),
urlreq.quote(self._req.env.get('REMOTE_USER', ''))) urlreq.quote(self._wsgireq.env.get('REMOTE_USER', '')))
def addcapabilities(self, repo, caps): def addcapabilities(self, repo, caps):
caps.append('httpheader=%d' % caps.append('httpheader=%d' %
repo.ui.configint('server', 'maxhttpheaderlen')) repo.ui.configint('server', 'maxhttpheaderlen'))
if repo.ui.configbool('experimental', 'httppostargs'): if repo.ui.configbool('experimental', 'httppostargs'):
caps.append('httppostargs') caps.append('httppostargs')
# FUTURE advertise 0.2rx once support is implemented # FUTURE advertise 0.2rx once support is implemented
# This method exists mostly so that extensions like remotefilelog can # This method exists mostly so that extensions like remotefilelog can
# disable a kludgey legacy method only over http. As of early 2018, # disable a kludgey legacy method only over http. As of early 2018,
# there are no other known users, so with any luck we can discard this # there are no other known users, so with any luck we can discard this
# hook if remotefilelog becomes a first-party extension. # hook if remotefilelog becomes a first-party extension.
def iscmd(cmd): def iscmd(cmd):
return cmd in wireproto.commands 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. """Parse the HTTP request for a wire protocol request.
If the current request appears to be a wire protocol request, this If the current request appears to be a wire protocol request, this
function returns a dict with details about that request, including function returns a dict with details about that request, including
an ``abstractprotocolserver`` instance suitable for handling the an ``abstractprotocolserver`` instance suitable for handling the
request. Otherwise, ``None`` is returned. request. Otherwise, ``None`` is returned.
``req`` is a ``wsgirequest`` instance. ``wsgireq`` is a ``wsgirequest`` instance.
""" """
repo = rctx.repo repo = rctx.repo
# HTTP version 1 wire protocol requests are denoted by a "cmd" query # 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 # string parameter. If it isn't present, this isn't a wire protocol
# request. # request.
if 'cmd' not in req.form: if 'cmd' not in wsgireq.form:
return None 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. # The "cmd" request parameter is used by both the wire protocol and hgweb.
# While not all wire protocol commands are available for all transports, # 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 # 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 # route it to a protocol handler. This is better than routing possible
# wire protocol requests to hgweb because it prevents hgweb from using # wire protocol requests to hgweb because it prevents hgweb from using
# known wire protocol commands and it is less confusing for machine # known wire protocol commands and it is less confusing for machine
# clients. # clients.
if not iscmd(cmd): if not iscmd(cmd):
return None return None
proto = httpv1protocolhandler(req, repo.ui, proto = httpv1protocolhandler(wsgireq, repo.ui,
lambda perm: checkperm(rctx, req, perm)) lambda perm: checkperm(rctx, wsgireq, perm))
return { return {
'cmd': cmd, 'cmd': cmd,
'proto': proto, 'proto': proto,
'dispatch': lambda: _callhttp(repo, req, proto, cmd), 'dispatch': lambda: _callhttp(repo, wsgireq, proto, cmd),
'handleerror': lambda ex: _handlehttperror(ex, req, 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. """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(req, r'X-HgProto').split(' ') protocaps = decodevaluefromheaders(wsgireq, r'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, req, proto, cmd): def _callhttp(repo, wsgireq, 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
for chunk in gen: for chunk in gen:
yield chunk yield chunk
if not wireproto.commands.commandavailable(cmd, proto): if not wireproto.commands.commandavailable(cmd, proto):
req.respond(HTTP_OK, HGERRTYPE, wsgireq.respond(HTTP_OK, HGERRTYPE,
body=_('requested wire protocol command is not available ' body=_('requested wire protocol command is not '
'over HTTP')) 'available over HTTP'))
return [] return []
proto.checkperm(wireproto.commands[cmd].permission) proto.checkperm(wireproto.commands[cmd].permission)
rsp = wireproto.dispatch(repo, proto, cmd) rsp = wireproto.dispatch(repo, proto, cmd)
if isinstance(rsp, bytes): if isinstance(rsp, bytes):
req.respond(HTTP_OK, HGTYPE, body=rsp) wsgireq.respond(HTTP_OK, HGTYPE, body=rsp)
return [] return []
elif isinstance(rsp, wireprototypes.bytesresponse): elif isinstance(rsp, wireprototypes.bytesresponse):
req.respond(HTTP_OK, HGTYPE, body=rsp.data) wsgireq.respond(HTTP_OK, HGTYPE, body=rsp.data)
return [] return []
elif isinstance(rsp, wireprototypes.streamreslegacy): elif isinstance(rsp, wireprototypes.streamreslegacy):
gen = rsp.gen gen = rsp.gen
req.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, req, rsp.prefer_uncompressed) repo.ui, wsgireq, 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)
req.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)
req.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().
req.drain() wsgireq.drain()
rsp = '0\n%s\n' % rsp.res rsp = '0\n%s\n' % rsp.res
req.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
req.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, req, cmd): def _handlehttperror(e, wsgireq, 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 (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. # But not if Expect: 100-continue is being used.
(req.env.get('HTTP_EXPECT', (wsgireq.env.get('HTTP_EXPECT',
'').lower() != '100-continue') or '').lower() != '100-continue') or
# Or the non-httplib HTTP library is being advertised by # Or the non-httplib HTTP library is being advertised by
# the client. # the client.
req.env.get('X-HgHttp2', '')): wsgireq.env.get('X-HgHttp2', '')):
req.drain() wsgireq.drain()
else: else:
req.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.
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 '' return ''
def _sshv1respondbytes(fout, value): def _sshv1respondbytes(fout, value):
"""Send a bytes response for protocol version 1.""" """Send a bytes response for protocol version 1."""
fout.write('%d\n' % len(value)) fout.write('%d\n' % len(value))
fout.write(value) fout.write(value)
fout.flush() fout.flush()