hgweb_mod.py
491 lines
| 17.2 KiB
| text/x-python
|
PythonLexer
|
r2391 | # hgweb/hgweb_mod.py - Web interface for a repository. | ||
|
r2356 | # | ||
# Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net> | ||||
|
r4635 | # Copyright 2005-2007 Matt Mackall <mpm@selenic.com> | ||
|
r2356 | # | ||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r2356 | |||
|
r27046 | from __future__ import absolute_import | ||
|
r26220 | import contextlib | ||
|
r26162 | import os | ||
|
r27046 | |||
from .common import ( | ||||
ErrorResponse, | ||||
HTTP_BAD_REQUEST, | ||||
HTTP_NOT_FOUND, | ||||
HTTP_NOT_MODIFIED, | ||||
HTTP_OK, | ||||
HTTP_SERVER_ERROR, | ||||
caching, | ||||
|
r30766 | cspvalues, | ||
|
r27046 | permhooks, | ||
) | ||||
from .request import wsgirequest | ||||
from .. import ( | ||||
encoding, | ||||
error, | ||||
hg, | ||||
hook, | ||||
|
r29787 | profiling, | ||
|
r34516 | pycompat, | ||
|
r27046 | repoview, | ||
templatefilters, | ||||
templater, | ||||
ui as uimod, | ||||
util, | ||||
) | ||||
from . import ( | ||||
protocol, | ||||
webcommands, | ||||
webutil, | ||||
wsgicgi, | ||||
) | ||||
|
r2356 | |||
|
r6779 | perms = { | ||
'changegroup': 'pull', | ||||
'changegroupsubset': 'pull', | ||||
|
r13741 | 'getbundle': 'pull', | ||
|
r11370 | 'stream_out': 'pull', | ||
'listkeys': 'pull', | ||||
|
r6779 | 'unbundle': 'push', | ||
|
r11370 | 'pushkey': 'push', | ||
|
r6779 | } | ||
r30749 | archivespecs = util.sortdict(( | |||
('zip', ('application/zip', 'zip', '.zip', None)), | ||||
('gz', ('application/x-gzip', 'tgz', '.tar.gz', None)), | ||||
('bz2', ('application/x-bzip2', 'tbz2', '.tar.bz2', None)), | ||||
)) | ||||
|
r34516 | def getstyle(req, configfn, templatepath): | ||
fromreq = req.form.get('style', [None])[0] | ||||
if fromreq is not None: | ||||
fromreq = pycompat.sysbytes(fromreq) | ||||
styles = ( | ||||
fromreq, | ||||
configfn('web', 'style'), | ||||
'paper', | ||||
) | ||||
return styles, templater.stylemap(styles, templatepath) | ||||
|
r18515 | def makebreadcrumb(url, prefix=''): | ||
|
r18258 | '''Return a 'URL breadcrumb' list | ||
A 'URL breadcrumb' is a list of URL-name pairs, | ||||
corresponding to each of the path items on a URL. | ||||
This can be used to create path navigation entries. | ||||
''' | ||||
if url.endswith('/'): | ||||
url = url[:-1] | ||||
|
r18515 | if prefix: | ||
url = '/' + prefix + url | ||||
|
r18258 | relpath = url | ||
if relpath.startswith('/'): | ||||
relpath = relpath[1:] | ||||
breadcrumb = [] | ||||
urlel = url | ||||
pathitems = [''] + relpath.split('/') | ||||
for pathel in reversed(pathitems): | ||||
if not pathel or not urlel: | ||||
break | ||||
breadcrumb.append({'url': urlel, 'name': pathel}) | ||||
urlel = os.path.dirname(urlel) | ||||
return reversed(breadcrumb) | ||||
|
r26134 | class requestcontext(object): | ||
"""Holds state/context for an individual request. | ||||
Servers can be multi-threaded. Holding state on the WSGI application | ||||
is prone to race conditions. Instances of this class exist to hold | ||||
mutable and race-free state for requests. | ||||
""" | ||||
|
r26219 | def __init__(self, app, repo): | ||
self.repo = repo | ||||
|
r26217 | self.reponame = app.reponame | ||
|
r26134 | |||
r30749 | self.archivespecs = archivespecs | |||
|
r34591 | self.maxchanges = self.configint('web', 'maxchanges') | ||
|
r34242 | self.stripecount = self.configint('web', 'stripes') | ||
|
r34589 | self.maxshortchanges = self.configint('web', 'maxshortchanges') | ||
|
r34590 | self.maxfiles = self.configint('web', 'maxfiles') | ||
|
r34603 | self.allowpull = self.configbool('web', 'allowpull') | ||
|
r26135 | |||
|
r26163 | # we use untrusted=False to prevent a repo owner from using | ||
# web.templates in .hg/hgrc to get access to any file readable | ||||
# by the user running the CGI script | ||||
|
r26217 | self.templatepath = self.config('web', 'templates', untrusted=False) | ||
|
r26163 | |||
|
r26164 | # This object is more expensive to build than simple config values. | ||
# It is shared across requests. The app will replace the object | ||||
# if it is updated. Since this is a reference and nothing should | ||||
# modify the underlying object, it should be constant for the lifetime | ||||
# of the request. | ||||
|
r26217 | self.websubtable = app.websubtable | ||
|
r26164 | |||
|
r30766 | self.csp, self.nonce = cspvalues(self.repo.ui) | ||
|
r26135 | # Trust the settings from the .hg/hgrc files by default. | ||
|
r33328 | def config(self, section, name, default=uimod._unset, untrusted=True): | ||
|
r26135 | return self.repo.ui.config(section, name, default, | ||
untrusted=untrusted) | ||||
|
r33328 | def configbool(self, section, name, default=uimod._unset, untrusted=True): | ||
|
r26135 | return self.repo.ui.configbool(section, name, default, | ||
untrusted=untrusted) | ||||
|
r33328 | def configint(self, section, name, default=uimod._unset, untrusted=True): | ||
|
r26135 | return self.repo.ui.configint(section, name, default, | ||
untrusted=untrusted) | ||||
|
r33328 | def configlist(self, section, name, default=uimod._unset, untrusted=True): | ||
|
r26135 | return self.repo.ui.configlist(section, name, default, | ||
untrusted=untrusted) | ||||
|
r26136 | def archivelist(self, nodeid): | ||
allowed = self.configlist('web', 'allow_archive') | ||||
r30748 | for typ, spec in self.archivespecs.iteritems(): | |||
|
r26136 | if typ in allowed or self.configbool('web', 'allow%s' % typ): | ||
yield {'type': typ, 'extension': spec[2], 'node': nodeid} | ||||
|
r18258 | |||
|
r26183 | def templater(self, req): | ||
# determine scheme, port and server name | ||||
# this is needed to create absolute urls | ||||
proto = req.env.get('wsgi.url_scheme') | ||||
if proto == 'https': | ||||
proto = 'https' | ||||
default_port = '443' | ||||
else: | ||||
proto = 'http' | ||||
default_port = '80' | ||||
|
r34705 | port = req.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) | ||||
|
r34613 | logourl = self.config('web', 'logourl') | ||
|
r34612 | logoimg = self.config('web', 'logoimg') | ||
|
r26183 | staticurl = self.config('web', 'staticurl') or req.url + 'static/' | ||
if not staticurl.endswith('/'): | ||||
staticurl += '/' | ||||
# some functions for the templater | ||||
def motd(**map): | ||||
|
r34588 | yield self.config('web', 'motd') | ||
|
r26183 | |||
# figure out which style to use | ||||
vars = {} | ||||
|
r34516 | styles, (style, mapfile) = getstyle(req, self.config, | ||
self.templatepath) | ||||
|
r26183 | if style == styles[0]: | ||
vars['style'] = style | ||||
|
r34807 | start = '&' if req.url[-1] == r'?' else '?' | ||
|
r26183 | sessionvars = webutil.sessionvars(vars, start) | ||
if not self.reponame: | ||||
|
r34587 | self.reponame = (self.config('web', 'name', '') | ||
|
r26217 | or req.env.get('REPO_NAME') | ||
or req.url.strip('/') or self.repo.root) | ||||
|
r26183 | |||
def websubfilter(text): | ||||
|
r27008 | return templatefilters.websub(text, self.websubtable) | ||
|
r26183 | |||
# create the templater | ||||
|
r28954 | defaults = { | ||
'url': req.url, | ||||
'logourl': logourl, | ||||
'logoimg': logoimg, | ||||
'staticurl': staticurl, | ||||
'urlbase': urlbase, | ||||
'repo': self.reponame, | ||||
'encoding': encoding.encoding, | ||||
'motd': motd, | ||||
'sessionvars': sessionvars, | ||||
'pathdef': makebreadcrumb(req.url), | ||||
'style': style, | ||||
|
r30766 | 'nonce': self.nonce, | ||
|
r28954 | } | ||
tmpl = templater.templater.frommapfile(mapfile, | ||||
filters={'websub': websubfilter}, | ||||
defaults=defaults) | ||||
|
r26183 | return tmpl | ||
|
r2356 | class hgweb(object): | ||
|
r26132 | """HTTP server for individual repositories. | ||
Instances of this class serve HTTP responses for a particular | ||||
repository. | ||||
Instances are typically used as WSGI applications. | ||||
Some servers are multi-threaded. On these servers, there may | ||||
be multiple active threads inside __call__. | ||||
""" | ||||
|
r10994 | def __init__(self, repo, name=None, baseui=None): | ||
|
r4874 | if isinstance(repo, str): | ||
|
r10994 | if baseui: | ||
u = baseui.copy() | ||||
else: | ||||
|
r30559 | u = uimod.ui.load() | ||
|
r20168 | r = hg.repository(u, repo) | ||
|
r2356 | else: | ||
|
r22087 | # we trust caller to give us a private copy | ||
|
r20168 | r = repo | ||
|
r2356 | |||
|
r20790 | r.ui.setconfig('ui', 'report_untrusted', 'off', 'hgweb') | ||
r.baseui.setconfig('ui', 'report_untrusted', 'off', 'hgweb') | ||||
r.ui.setconfig('ui', 'nontty', 'true', 'hgweb') | ||||
r.baseui.setconfig('ui', 'nontty', 'true', 'hgweb') | ||||
|
r26294 | # resolve file patterns relative to repo root | ||
r.ui.setconfig('ui', 'forcecwd', r.root, 'hgweb') | ||||
r.baseui.setconfig('ui', 'forcecwd', r.root, 'hgweb') | ||||
|
r25488 | # displaying bundling progress bar while serving feel wrong and may | ||
# break some wsgi implementation. | ||||
r.ui.setconfig('progress', 'disable', 'true', 'hgweb') | ||||
r.baseui.setconfig('progress', 'disable', 'true', 'hgweb') | ||||
|
r26220 | self._repos = [hg.cachedlocalrepo(self._webifyrepo(r))] | ||
self._lastrepo = self._repos[0] | ||||
|
r5833 | hook.redirect(True) | ||
|
r2356 | self.reponame = name | ||
|
r3555 | |||
|
r26218 | def _webifyrepo(self, repo): | ||
repo = getwebview(repo) | ||||
self.websubtable = webutil.getwebsubs(repo) | ||||
return repo | ||||
|
r26220 | @contextlib.contextmanager | ||
def _obtainrepo(self): | ||||
"""Obtain a repo unique to the caller. | ||||
Internally we maintain a stack of cachedlocalrepo instances | ||||
to be handed out. If one is available, we pop it and return it, | ||||
ensuring it is up to date in the process. If one is not available, | ||||
we clone the most recently used repo instance and return it. | ||||
|
r26219 | |||
|
r26220 | It is currently possible for the stack to grow without bounds | ||
if the server allows infinite threads. However, servers should | ||||
have a thread limit, thus establishing our limit. | ||||
""" | ||||
if self._repos: | ||||
cached = self._repos.pop() | ||||
r, created = cached.fetch() | ||||
else: | ||||
cached = self._lastrepo.copy() | ||||
r, created = cached.fetch() | ||||
|
r26240 | if created: | ||
r = self._webifyrepo(r) | ||||
|
r26220 | |||
self._lastrepo = cached | ||||
self.mtime = cached.mtime | ||||
try: | ||||
yield r | ||||
finally: | ||||
self._repos.append(cached) | ||||
|
r2356 | |||
|
r5591 | def run(self): | ||
|
r26132 | """Start a server from CGI environment. | ||
Modern servers should be using WSGI and should avoid this | ||||
method, if possible. | ||||
""" | ||||
|
r30636 | if not encoding.environ.get('GATEWAY_INTERFACE', | ||
'').startswith("CGI/1."): | ||||
|
r8663 | raise RuntimeError("This function is only intended to be " | ||
"called while running as a CGI script.") | ||||
|
r5591 | wsgicgi.launch(self) | ||
def __call__(self, env, respond): | ||||
|
r26132 | """Run the WSGI application. | ||
This may be called by multiple threads. | ||||
""" | ||||
|
r5591 | req = wsgirequest(env, respond) | ||
|
r6784 | return self.run_wsgi(req) | ||
|
r5591 | |||
def run_wsgi(self, req): | ||||
|
r26132 | """Internal method to run the WSGI application. | ||
|
r5591 | |||
|
r26132 | This is typically only called by Mercurial. External consumers | ||
should be using instances of this class as the WSGI application. | ||||
""" | ||||
|
r26220 | with self._obtainrepo() as repo: | ||
r32788 | profile = repo.ui.configbool('profiling', 'enabled') | |||
with profiling.profile(repo.ui, enabled=profile): | ||||
|
r29787 | for r in self._runwsgi(req, repo): | ||
yield r | ||||
|
r26220 | |||
def _runwsgi(self, req, repo): | ||||
|
r26219 | rctx = requestcontext(self, repo) | ||
|
r5591 | |||
|
r26160 | # This state is global across all threads. | ||
|
r34236 | encoding.encoding = rctx.config('web', 'encoding') | ||
|
r26160 | rctx.repo.ui.environ = req.env | ||
|
r5591 | |||
|
r30766 | 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)) | ||||
|
r5596 | # work with CGI variables to create coherent structure | ||
# use SCRIPT_NAME, PATH_INFO and QUERY_STRING as well as our REPO_NAME | ||||
|
r5591 | |||
|
r34705 | req.url = req.env[r'SCRIPT_NAME'] | ||
|
r5596 | if not req.url.endswith('/'): | ||
req.url += '/' | ||||
|
r32004 | if req.env.get('REPO_NAME'): | ||
|
r34705 | req.url += req.env[r'REPO_NAME'] + r'/' | ||
|
r5591 | |||
|
r34705 | if r'PATH_INFO' in req.env: | ||
parts = req.env[r'PATH_INFO'].strip('/').split('/') | ||||
repo_parts = req.env.get(r'REPO_NAME', r'').split(r'/') | ||||
|
r5596 | if parts[:len(repo_parts)] == repo_parts: | ||
parts = parts[len(repo_parts):] | ||||
query = '/'.join(parts) | ||||
else: | ||||
|
r34705 | query = req.env[r'QUERY_STRING'].partition(r'&')[0] | ||
query = query.partition(r';')[0] | ||||
|
r5591 | |||
|
r8860 | # process this if it's a protocol request | ||
# protocol bits don't need to create any URLs | ||||
# and the clients always use the old URL structure | ||||
|
r34705 | cmd = pycompat.sysbytes(req.form.get(r'cmd', [r''])[0]) | ||
|
r11595 | if protocol.iscmd(cmd): | ||
|
r13445 | try: | ||
if query: | ||||
raise ErrorResponse(HTTP_NOT_FOUND) | ||||
if cmd in perms: | ||||
|
r26134 | self.check_perm(rctx, req, perms[cmd]) | ||
|
r26209 | return protocol.call(rctx.repo, req, cmd) | ||
|
r25660 | except ErrorResponse as inst: | ||
|
r13571 | # A client that sends unbundle without 100-continue will | ||
# break if we respond early. | ||||
if (cmd == 'unbundle' and | ||||
|
r14991 | (req.env.get('HTTP_EXPECT', | ||
'').lower() != '100-continue') or | ||||
req.env.get('X-HgHttp2', '')): | ||||
|
r13445 | req.drain() | ||
|
r19488 | else: | ||
|
r34741 | req.headers.append((r'Connection', r'Close')) | ||
|
r18352 | req.respond(inst, protocol.HGTYPE, | ||
|
r26200 | body='0\n%s\n' % inst) | ||
|
r18352 | return '' | ||
|
r8860 | |||
|
r5596 | # translate user-visible url structure to internal structure | ||
args = query.split('/', 2) | ||||
|
r34705 | if r'cmd' not in req.form and args and args[0]: | ||
|
r5591 | cmd = args.pop(0) | ||
style = cmd.rfind('-') | ||||
if style != -1: | ||||
req.form['style'] = [cmd[:style]] | ||||
|
r10282 | cmd = cmd[style + 1:] | ||
|
r5596 | |||
|
r5591 | # avoid accepting e.g. style parameter as command | ||
|
r14953 | if util.safehasattr(webcommands, cmd): | ||
|
r34705 | req.form[r'cmd'] = [cmd] | ||
|
r5591 | |||
|
r7287 | if cmd == 'static': | ||
req.form['file'] = ['/'.join(args)] | ||||
else: | ||||
if args and args[0]: | ||||
r25777 | node = args.pop(0).replace('%2F', '/') | |||
|
r7287 | req.form['node'] = [node] | ||
if args: | ||||
req.form['file'] = args | ||||
|
r5591 | |||
|
r9731 | ua = req.env.get('HTTP_USER_AGENT', '') | ||
if cmd == 'rev' and 'mercurial' in ua: | ||||
req.form['style'] = ['raw'] | ||||
|
r7287 | if cmd == 'archive': | ||
|
r5591 | fn = req.form['node'][0] | ||
|
r26136 | for type_, spec in rctx.archivespecs.iteritems(): | ||
|
r5591 | ext = spec[2] | ||
if fn.endswith(ext): | ||||
req.form['node'] = [fn[:-len(ext)]] | ||||
req.form['type'] = [type_] | ||||
|
r6149 | # process the web interface request | ||
|
r5599 | |||
try: | ||||
|
r26183 | tmpl = rctx.templater(req) | ||
|
r8859 | ctype = tmpl('mimetype', encoding=encoding.encoding) | ||
|
r6391 | ctype = templater.stringify(ctype) | ||
|
r6149 | |||
|
r7562 | # check read permissions non-static content | ||
if cmd != 'static': | ||||
|
r26134 | self.check_perm(rctx, req, None) | ||
|
r7336 | |||
|
r6149 | if cmd == '': | ||
|
r34705 | req.form[r'cmd'] = [tmpl.cache['default']] | ||
cmd = req.form[r'cmd'][0] | ||||
|
r5890 | |||
|
r30766 | # Don't enable caching if using a CSP nonce because then it wouldn't | ||
# be a nonce. | ||||
|
r34606 | if rctx.configbool('web', 'cache') and not rctx.nonce: | ||
|
r13966 | caching(self, req) # sets ETag header or raises NOT_MODIFIED | ||
|
r6149 | if cmd not in webcommands.__all__: | ||
|
r6368 | msg = 'no such method: %s' % cmd | ||
|
r6149 | raise ErrorResponse(HTTP_BAD_REQUEST, msg) | ||
|
r34705 | elif cmd == 'file' and r'raw' in req.form.get(r'style', []): | ||
|
r26217 | rctx.ctype = ctype | ||
|
r26134 | content = webcommands.rawfile(rctx, req, tmpl) | ||
|
r6149 | else: | ||
|
r26134 | content = getattr(webcommands, cmd)(rctx, req, tmpl) | ||
|
r6149 | req.respond(HTTP_OK, ctype) | ||
|
r5890 | |||
|
r7396 | return content | ||
|
r5600 | |||
|
r25660 | except (error.LookupError, error.RepoLookupError) as err: | ||
|
r5993 | req.respond(HTTP_NOT_FOUND, ctype) | ||
|
r6374 | msg = str(err) | ||
|
r18855 | if (util.safehasattr(err, 'name') and | ||
not isinstance(err, error.ManifestLookupError)): | ||||
|
r6368 | msg = 'revision not found: %s' % err.name | ||
|
r7396 | return tmpl('error', error=msg) | ||
|
r25660 | except (error.RepoError, error.RevlogError) as inst: | ||
|
r5993 | req.respond(HTTP_SERVER_ERROR, ctype) | ||
|
r7396 | return tmpl('error', error=str(inst)) | ||
|
r25660 | except ErrorResponse as inst: | ||
|
r7740 | req.respond(inst, ctype) | ||
|
r12739 | if inst.code == HTTP_NOT_MODIFIED: | ||
# Not allowed to return a body on a 304 | ||||
return [''] | ||||
|
r26200 | return tmpl('error', error=str(inst)) | ||
|
r5599 | |||
|
r26134 | def check_perm(self, rctx, req, op): | ||
|
r22200 | for permhook in permhooks: | ||
|
r26134 | permhook(rctx, req, op) | ||
|
r26208 | |||
def getwebview(repo): | ||||
"""The 'web.view' config controls changeset filter to hgweb. Possible | ||||
values are ``served``, ``visible`` and ``all``. Default is ``served``. | ||||
The ``served`` filter only shows changesets that can be pulled from the | ||||
hgweb instance. The``visible`` filter includes secret changesets but | ||||
still excludes "hidden" one. | ||||
See the repoview module for details. | ||||
The option has been around undocumented since Mercurial 2.5, but no | ||||
user ever asked about it. So we better keep it undocumented for now.""" | ||||
|
r34585 | # experimental config: web.view | ||
viewconfig = repo.ui.config('web', 'view', untrusted=True) | ||||
|
r26208 | if viewconfig == 'all': | ||
return repo.unfiltered() | ||||
elif viewconfig in repoview.filtertable: | ||||
return repo.filtered(viewconfig) | ||||
else: | ||||
return repo.filtered('served') | ||||