hgweb_mod.py
312 lines
| 11.8 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 | # | ||
# This software may be used and distributed according to the terms | ||||
# of the GNU General Public License, incorporated herein by reference. | ||||
|
r7873 | import os | ||
|
r7948 | from mercurial import ui, hg, util, hook, error, encoding | ||
|
r7633 | from mercurial import templater, templatefilters | ||
|
r7966 | from common import get_mtime, ErrorResponse | ||
|
r5993 | from common import HTTP_OK, HTTP_BAD_REQUEST, HTTP_NOT_FOUND, HTTP_SERVER_ERROR | ||
|
r6926 | from common import HTTP_UNAUTHORIZED, HTTP_METHOD_NOT_ALLOWED | ||
|
r5566 | from request import wsgirequest | ||
|
r6392 | import webcommands, protocol, webutil | ||
|
r2356 | |||
|
r6779 | perms = { | ||
'changegroup': 'pull', | ||||
'changegroupsubset': 'pull', | ||||
'unbundle': 'push', | ||||
'stream_out': 'pull', | ||||
} | ||||
|
r2356 | class hgweb(object): | ||
|
r6141 | def __init__(self, repo, name=None): | ||
|
r4874 | if isinstance(repo, str): | ||
|
r8136 | parentui = ui.ui() | ||
parentui.setconfig('ui', 'report_untrusted', 'off') | ||||
parentui.setconfig('ui', 'interactive', 'off') | ||||
|
r5289 | self.repo = hg.repository(parentui, repo) | ||
|
r2356 | else: | ||
self.repo = repo | ||||
|
r5833 | hook.redirect(True) | ||
|
r2356 | self.mtime = -1 | ||
self.reponame = name | ||||
self.archives = 'zip', 'gz', 'bz2' | ||||
|
r2666 | self.stripecount = 1 | ||
|
r3555 | # a repo owner may set web.templates in .hg/hgrc to get any file | ||
# readable by the user running the CGI script | ||||
|
r7966 | self.templatepath = self.config('web', 'templates') | ||
|
r3555 | |||
# The CGI scripts are often run by a user different from the repo owner. | ||||
# Trust the settings from the .hg/hgrc files by default. | ||||
def config(self, section, name, default=None, untrusted=True): | ||||
return self.repo.ui.config(section, name, default, | ||||
untrusted=untrusted) | ||||
def configbool(self, section, name, default=False, untrusted=True): | ||||
return self.repo.ui.configbool(section, name, default, | ||||
untrusted=untrusted) | ||||
def configlist(self, section, name, default=None, untrusted=True): | ||||
return self.repo.ui.configlist(section, name, default, | ||||
untrusted=untrusted) | ||||
|
r2356 | |||
def refresh(self): | ||||
mtime = get_mtime(self.repo.root) | ||||
if mtime != self.mtime: | ||||
self.mtime = mtime | ||||
self.repo = hg.repository(self.repo.ui, self.repo.root) | ||||
|
r3555 | self.maxchanges = int(self.config("web", "maxchanges", 10)) | ||
self.stripecount = int(self.config("web", "stripes", 1)) | ||||
self.maxshortchanges = int(self.config("web", "maxshortchanges", 60)) | ||||
self.maxfiles = int(self.config("web", "maxfiles", 10)) | ||||
self.allowpull = self.configbool("web", "allowpull", True) | ||||
|
r7948 | self.encoding = self.config("web", "encoding", encoding.encoding) | ||
|
r2356 | |||
|
r5591 | def run(self): | ||
if not os.environ.get('GATEWAY_INTERFACE', '').startswith("CGI/1."): | ||||
raise RuntimeError("This function is only intended to be called while running as a CGI script.") | ||||
import mercurial.hgweb.wsgicgi as wsgicgi | ||||
wsgicgi.launch(self) | ||||
def __call__(self, env, respond): | ||||
req = wsgirequest(env, respond) | ||||
|
r6784 | return self.run_wsgi(req) | ||
|
r5591 | |||
def run_wsgi(self, req): | ||||
|
r5596 | self.refresh() | ||
|
r5591 | |||
|
r6777 | # 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 | ||||
cmd = req.form.get('cmd', [''])[0] | ||||
if cmd and cmd in protocol.__all__: | ||||
|
r6926 | try: | ||
if cmd in perms: | ||||
|
r7180 | try: | ||
self.check_perm(req, perms[cmd]) | ||||
except ErrorResponse, inst: | ||||
if cmd == 'unbundle': | ||||
req.drain() | ||||
raise | ||||
|
r6926 | method = getattr(protocol, cmd) | ||
return method(self.repo, req) | ||||
except ErrorResponse, inst: | ||||
|
r7740 | req.respond(inst, protocol.HGTYPE) | ||
|
r6926 | if not inst.message: | ||
return [] | ||||
return '0\n%s\n' % inst.message, | ||||
|
r6777 | |||
|
r5596 | # work with CGI variables to create coherent structure | ||
# use SCRIPT_NAME, PATH_INFO and QUERY_STRING as well as our REPO_NAME | ||||
|
r5591 | |||
|
r5596 | req.url = req.env['SCRIPT_NAME'] | ||
if not req.url.endswith('/'): | ||||
req.url += '/' | ||||
|
r5915 | if 'REPO_NAME' in req.env: | ||
|
r5596 | req.url += req.env['REPO_NAME'] + '/' | ||
|
r5591 | |||
|
r6459 | if 'PATH_INFO' in req.env: | ||
parts = req.env['PATH_INFO'].strip('/').split('/') | ||||
|
r5596 | repo_parts = req.env.get('REPO_NAME', '').split('/') | ||
if parts[:len(repo_parts)] == repo_parts: | ||||
parts = parts[len(repo_parts):] | ||||
query = '/'.join(parts) | ||||
else: | ||||
query = req.env['QUERY_STRING'].split('&', 1)[0] | ||||
query = query.split(';', 1)[0] | ||||
|
r5591 | |||
|
r5596 | # translate user-visible url structure to internal structure | ||
args = query.split('/', 2) | ||||
if '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]] | ||||
cmd = cmd[style+1:] | ||||
|
r5596 | |||
|
r5591 | # avoid accepting e.g. style parameter as command | ||
|
r6777 | if hasattr(webcommands, cmd): | ||
|
r5591 | req.form['cmd'] = [cmd] | ||
|
r6777 | else: | ||
cmd = '' | ||||
|
r5591 | |||
|
r7287 | if cmd == 'static': | ||
req.form['file'] = ['/'.join(args)] | ||||
else: | ||||
if args and args[0]: | ||||
node = args.pop(0) | ||||
req.form['node'] = [node] | ||||
if args: | ||||
req.form['file'] = args | ||||
|
r5591 | |||
|
r7287 | if cmd == 'archive': | ||
|
r5591 | fn = req.form['node'][0] | ||
for type_, spec in self.archive_specs.iteritems(): | ||||
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: | ||||
|
r6149 | tmpl = self.templater(req) | ||
|
r6391 | ctype = tmpl('mimetype', encoding=self.encoding) | ||
ctype = templater.stringify(ctype) | ||||
|
r6149 | |||
|
r7562 | # check read permissions non-static content | ||
if cmd != 'static': | ||||
self.check_perm(req, None) | ||||
|
r7336 | |||
|
r6149 | if cmd == '': | ||
req.form['cmd'] = [tmpl.cache['default']] | ||||
cmd = req.form['cmd'][0] | ||||
|
r5890 | |||
|
r6149 | if cmd not in webcommands.__all__: | ||
|
r6368 | msg = 'no such method: %s' % cmd | ||
|
r6149 | raise ErrorResponse(HTTP_BAD_REQUEST, msg) | ||
elif cmd == 'file' and 'raw' in req.form.get('style', []): | ||||
self.ctype = ctype | ||||
content = webcommands.rawfile(self, req, tmpl) | ||||
else: | ||||
content = getattr(webcommands, cmd)(self, req, tmpl) | ||||
req.respond(HTTP_OK, ctype) | ||||
|
r5890 | |||
|
r7396 | return content | ||
|
r5600 | |||
|
r7633 | except error.LookupError, err: | ||
|
r5993 | req.respond(HTTP_NOT_FOUND, ctype) | ||
|
r6374 | msg = str(err) | ||
if 'manifest' not in msg: | ||||
|
r6368 | msg = 'revision not found: %s' % err.name | ||
|
r7396 | return tmpl('error', error=msg) | ||
|
r7637 | except (error.RepoError, error.RevlogError), inst: | ||
|
r5993 | req.respond(HTTP_SERVER_ERROR, ctype) | ||
|
r7396 | return tmpl('error', error=str(inst)) | ||
|
r5600 | except ErrorResponse, inst: | ||
|
r7740 | req.respond(inst, ctype) | ||
|
r7396 | return tmpl('error', error=inst.message) | ||
|
r5599 | |||
def templater(self, req): | ||||
|
r5596 | # determine scheme, port and server name | ||
# this is needed to create absolute urls | ||||
|
r5591 | |||
proto = req.env.get('wsgi.url_scheme') | ||||
if proto == 'https': | ||||
proto = 'https' | ||||
default_port = "443" | ||||
else: | ||||
proto = 'http' | ||||
default_port = "80" | ||||
port = req.env["SERVER_PORT"] | ||||
port = port != default_port and (":" + port) or "" | ||||
urlbase = '%s://%s%s' % (proto, req.env['SERVER_NAME'], port) | ||||
staticurl = self.config("web", "staticurl") or req.url + 'static/' | ||||
if not staticurl.endswith('/'): | ||||
staticurl += '/' | ||||
|
r5596 | # some functions for the templater | ||
def header(**map): | ||||
|
r6391 | yield tmpl('header', encoding=self.encoding, **map) | ||
|
r5596 | |||
def footer(**map): | ||||
|
r5600 | yield tmpl("footer", **map) | ||
|
r5596 | |||
def motd(**map): | ||||
yield self.config("web", "motd", "") | ||||
|
r5599 | # figure out which style to use | ||
|
r7345 | vars = {} | ||
|
r7337 | style = self.config("web", "style", "paper") | ||
|
r5915 | if 'style' in req.form: | ||
|
r5596 | style = req.form['style'][0] | ||
|
r7345 | vars['style'] = style | ||
start = req.url[-1] == '?' and '&' or '?' | ||||
sessionvars = webutil.sessionvars(vars, start) | ||||
|
r7966 | mapfile = templater.stylemap(style, self.templatepath) | ||
|
r5596 | |||
|
r5591 | if not self.reponame: | ||
self.reponame = (self.config("web", "name") | ||||
or req.env.get('REPO_NAME') | ||||
or req.url.strip('/') or self.repo.root) | ||||
|
r5599 | # create the templater | ||
|
r5976 | tmpl = templater.templater(mapfile, templatefilters.filters, | ||
|
r5600 | defaults={"url": req.url, | ||
"staticurl": staticurl, | ||||
"urlbase": urlbase, | ||||
"repo": self.reponame, | ||||
"header": header, | ||||
"footer": footer, | ||||
"motd": motd, | ||||
"sessionvars": sessionvars | ||||
}) | ||||
return tmpl | ||||
|
r5591 | |||
|
r2356 | def archivelist(self, nodeid): | ||
|
r3555 | allowed = self.configlist("web", "allow_archive") | ||
|
r3260 | for i, spec in self.archive_specs.iteritems(): | ||
|
r3555 | if i in allowed or self.configbool("web", "allow" + i): | ||
|
r3260 | yield {"type" : i, "extension" : spec[2], "node" : nodeid} | ||
|
r2356 | |||
archive_specs = { | ||||
|
r2361 | 'bz2': ('application/x-tar', 'tbz2', '.tar.bz2', None), | ||
'gz': ('application/x-tar', 'tgz', '.tar.gz', None), | ||||
|
r2356 | 'zip': ('application/zip', 'zip', '.zip', None), | ||
} | ||||
|
r6779 | def check_perm(self, req, op): | ||
'''Check permission for operation based on request data (including | ||||
|
r7336 | authentication info). Return if op allowed, else raise an ErrorResponse | ||
exception.''' | ||||
user = req.env.get('REMOTE_USER') | ||||
deny_read = self.configlist('web', 'deny_read') | ||||
if deny_read and (not user or deny_read == ['*'] or user in deny_read): | ||||
raise ErrorResponse(HTTP_UNAUTHORIZED, 'read not authorized') | ||||
allow_read = self.configlist('web', 'allow_read') | ||||
|
r7575 | result = (not allow_read) or (allow_read == ['*']) | ||
|
r7831 | if not (result or user in allow_read): | ||
|
r7336 | raise ErrorResponse(HTTP_UNAUTHORIZED, 'read not authorized') | ||
|
r6779 | |||
|
r6926 | if op == 'pull' and not self.allowpull: | ||
|
r7563 | raise ErrorResponse(HTTP_UNAUTHORIZED, 'pull not authorized') | ||
|
r7575 | elif op == 'pull' or op is None: # op is None for interface requests | ||
|
r6926 | return | ||
|
r6779 | |||
# enforce that you can only push using POST requests | ||||
if req.env['REQUEST_METHOD'] != 'POST': | ||||
|
r6926 | msg = 'push requires POST request' | ||
raise ErrorResponse(HTTP_METHOD_NOT_ALLOWED, msg) | ||||
|
r6779 | |||
# require ssl by default for pushing, auth info cannot be sniffed | ||||
# and replayed | ||||
scheme = req.env.get('wsgi.url_scheme') | ||||
if self.configbool('web', 'push_ssl', True) and scheme != 'https': | ||||
|
r6926 | raise ErrorResponse(HTTP_OK, 'ssl required') | ||
|
r2466 | |||
|
r6779 | deny = self.configlist('web', 'deny_push') | ||
|
r2466 | if deny and (not user or deny == ['*'] or user in deny): | ||
|
r6926 | raise ErrorResponse(HTTP_UNAUTHORIZED, 'push not authorized') | ||
|
r2466 | |||
|
r6779 | allow = self.configlist('web', 'allow_push') | ||
result = allow and (allow == ['*'] or user in allow) | ||||
if not result: | ||||
|
r6926 | raise ErrorResponse(HTTP_UNAUTHORIZED, 'push not authorized') | ||