server.py
293 lines
| 10.4 KiB
| text/x-python
|
PythonLexer
|
r2391 | # hgweb/server.py - The standalone hg web server. | ||
|
r2355 | # | ||
# Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net> | ||||
|
r4635 | # Copyright 2005-2007 Matt Mackall <mpm@selenic.com> | ||
|
r2355 | # | ||
# This software may be used and distributed according to the terms | ||||
# of the GNU General Public License, incorporated herein by reference. | ||||
|
r4016 | import os, sys, errno, urllib, BaseHTTPServer, socket, SocketServer, traceback | ||
|
r7637 | from mercurial import hg, util, error | ||
|
r3877 | from hgweb_mod import hgweb | ||
from hgwebdir_mod import hgwebdir | ||||
|
r7225 | from mercurial.i18n import _ | ||
|
r2355 | |||
def _splitURI(uri): | ||||
""" Return path and query splited from uri | ||||
Just like CGI environment, the path is unquoted, the query is | ||||
not. | ||||
""" | ||||
if '?' in uri: | ||||
path, query = uri.split('?', 1) | ||||
else: | ||||
path, query = uri, '' | ||||
return urllib.unquote(path), query | ||||
|
r2506 | class _error_logger(object): | ||
def __init__(self, handler): | ||||
self.handler = handler | ||||
def flush(self): | ||||
pass | ||||
|
r3130 | def write(self, str): | ||
|
r2506 | self.writelines(str.split('\n')) | ||
|
r3130 | def writelines(self, seq): | ||
|
r2506 | for msg in seq: | ||
self.handler.log_error("HG error: %s", msg) | ||||
|
r2355 | class _hgwebhandler(object, BaseHTTPServer.BaseHTTPRequestHandler): | ||
|
r4870 | |||
url_scheme = 'http' | ||||
|
r4957 | |||
|
r2355 | def __init__(self, *args, **kargs): | ||
|
r2434 | self.protocol_version = 'HTTP/1.1' | ||
|
r2355 | BaseHTTPServer.BaseHTTPRequestHandler.__init__(self, *args, **kargs) | ||
|
r5549 | def _log_any(self, fp, format, *args): | ||
fp.write("%s - - [%s] %s\n" % (self.client_address[0], | ||||
self.log_date_time_string(), | ||||
format % args)) | ||||
fp.flush() | ||||
|
r2355 | def log_error(self, format, *args): | ||
|
r5549 | self._log_any(self.server.errorlog, format, *args) | ||
|
r2355 | |||
def log_message(self, format, *args): | ||||
|
r5549 | self._log_any(self.server.accesslog, format, *args) | ||
|
r2355 | |||
|
r4860 | def do_write(self): | ||
try: | ||||
self.do_hgweb() | ||||
except socket.error, inst: | ||||
if inst[0] != errno.EPIPE: | ||||
raise | ||||
|
r2355 | def do_POST(self): | ||
try: | ||||
|
r4860 | self.do_write() | ||
|
r7280 | except StandardError: | ||
|
r4015 | self._start_response("500 Internal Server Error", []) | ||
self._write("Internal Server Error") | ||||
tb = "".join(traceback.format_exception(*sys.exc_info())) | ||||
self.log_error("Exception happened during processing request '%s':\n%s", | ||||
self.path, tb) | ||||
|
r2355 | |||
def do_GET(self): | ||||
self.do_POST() | ||||
def do_hgweb(self): | ||||
|
r5835 | path, query = _splitURI(self.path) | ||
|
r2355 | |||
env = {} | ||||
env['GATEWAY_INTERFACE'] = 'CGI/1.1' | ||||
env['REQUEST_METHOD'] = self.command | ||||
env['SERVER_NAME'] = self.server.server_name | ||||
env['SERVER_PORT'] = str(self.server.server_port) | ||||
|
r3263 | env['REQUEST_URI'] = self.path | ||
|
r5835 | env['SCRIPT_NAME'] = self.server.prefix | ||
env['PATH_INFO'] = path[len(self.server.prefix):] | ||||
|
r4359 | env['REMOTE_HOST'] = self.client_address[0] | ||
env['REMOTE_ADDR'] = self.client_address[0] | ||||
|
r2355 | if query: | ||
env['QUERY_STRING'] = query | ||||
if self.headers.typeheader is None: | ||||
env['CONTENT_TYPE'] = self.headers.type | ||||
else: | ||||
env['CONTENT_TYPE'] = self.headers.typeheader | ||||
length = self.headers.getheader('content-length') | ||||
if length: | ||||
env['CONTENT_LENGTH'] = length | ||||
|
r4633 | for header in [h for h in self.headers.keys() | ||
|
r2505 | if h not in ('content-type', 'content-length')]: | ||
hkey = 'HTTP_' + header.replace('-', '_').upper() | ||||
hval = self.headers.getheader(header) | ||||
hval = hval.replace('\n', '').strip() | ||||
if hval: | ||||
env[hkey] = hval | ||||
env['SERVER_PROTOCOL'] = self.request_version | ||||
|
r2506 | env['wsgi.version'] = (1, 0) | ||
|
r4871 | env['wsgi.url_scheme'] = self.url_scheme | ||
|
r2506 | env['wsgi.input'] = self.rfile | ||
env['wsgi.errors'] = _error_logger(self) | ||||
env['wsgi.multithread'] = isinstance(self.server, | ||||
SocketServer.ThreadingMixIn) | ||||
env['wsgi.multiprocess'] = isinstance(self.server, | ||||
SocketServer.ForkingMixIn) | ||||
env['wsgi.run_once'] = 0 | ||||
|
r2355 | |||
|
r2506 | self.close_connection = True | ||
self.saved_status = None | ||||
self.saved_headers = [] | ||||
self.sent_headers = False | ||||
|
r2508 | self.length = None | ||
|
r6784 | for chunk in self.server.application(env, self._start_response): | ||
self._write(chunk) | ||||
|
r2506 | |||
def send_headers(self): | ||||
if not self.saved_status: | ||||
raise AssertionError("Sending headers before start_response() called") | ||||
saved_status = self.saved_status.split(None, 1) | ||||
saved_status[0] = int(saved_status[0]) | ||||
self.send_response(*saved_status) | ||||
|
r2508 | should_close = True | ||
|
r2506 | for h in self.saved_headers: | ||
self.send_header(*h) | ||||
|
r2508 | if h[0].lower() == 'content-length': | ||
should_close = False | ||||
self.length = int(h[1]) | ||||
|
r2582 | # The value of the Connection header is a list of case-insensitive | ||
# tokens separated by commas and optional whitespace. | ||||
|
r2600 | if 'close' in [token.strip().lower() for token in | ||
|
r2582 | self.headers.get('connection', '').split(',')]: | ||
should_close = True | ||||
|
r2508 | if should_close: | ||
self.send_header('Connection', 'close') | ||||
self.close_connection = should_close | ||||
|
r2506 | self.end_headers() | ||
self.sent_headers = True | ||||
def _start_response(self, http_status, headers, exc_info=None): | ||||
code, msg = http_status.split(None, 1) | ||||
code = int(code) | ||||
self.saved_status = http_status | ||||
|
r2508 | bad_headers = ('connection', 'transfer-encoding') | ||
|
r4633 | self.saved_headers = [h for h in headers | ||
if h[0].lower() not in bad_headers] | ||||
|
r2506 | return self._write | ||
def _write(self, data): | ||||
if not self.saved_status: | ||||
raise AssertionError("data written before start_response() called") | ||||
elif not self.sent_headers: | ||||
self.send_headers() | ||||
|
r2508 | if self.length is not None: | ||
if len(data) > self.length: | ||||
raise AssertionError("Content-length header sent, but more bytes than specified are being written.") | ||||
self.length = self.length - len(data) | ||||
|
r2506 | self.wfile.write(data) | ||
self.wfile.flush() | ||||
|
r2355 | |||
|
r4860 | class _shgwebhandler(_hgwebhandler): | ||
|
r4870 | |||
url_scheme = 'https' | ||||
|
r4957 | |||
|
r4860 | def setup(self): | ||
self.connection = self.request | ||||
self.rfile = socket._fileobject(self.request, "rb", self.rbufsize) | ||||
self.wfile = socket._fileobject(self.request, "wb", self.wbufsize) | ||||
def do_write(self): | ||||
from OpenSSL.SSL import SysCallError | ||||
try: | ||||
super(_shgwebhandler, self).do_write() | ||||
except SysCallError, inst: | ||||
if inst.args[0] != errno.EPIPE: | ||||
raise | ||||
def handle_one_request(self): | ||||
from OpenSSL.SSL import SysCallError, ZeroReturnError | ||||
try: | ||||
super(_shgwebhandler, self).handle_one_request() | ||||
except (SysCallError, ZeroReturnError): | ||||
self.close_connection = True | ||||
pass | ||||
|
r2392 | def create_server(ui, repo): | ||
|
r2355 | use_threads = True | ||
def openlog(opt, default): | ||||
if opt and opt != '-': | ||||
|
r5690 | return open(opt, 'a') | ||
|
r2355 | return default | ||
|
r5083 | if repo is None: | ||
|
r5086 | myui = ui | ||
|
r5083 | else: | ||
|
r5086 | myui = repo.ui | ||
address = myui.config("web", "address", "") | ||||
port = int(myui.config("web", "port", 8000)) | ||||
|
r5970 | prefix = myui.config("web", "prefix", "") | ||
if prefix: | ||||
prefix = "/" + prefix.strip("/") | ||||
|
r5086 | use_ipv6 = myui.configbool("web", "ipv6") | ||
webdir_conf = myui.config("web", "webdir_conf") | ||||
|
r5150 | ssl_cert = myui.config("web", "certificate") | ||
|
r5086 | accesslog = openlog(myui.config("web", "accesslog", "-"), sys.stdout) | ||
errorlog = openlog(myui.config("web", "errorlog", "-"), sys.stderr) | ||||
|
r2355 | |||
if use_threads: | ||||
try: | ||||
from threading import activeCount | ||||
except ImportError: | ||||
use_threads = False | ||||
if use_threads: | ||||
_mixin = SocketServer.ThreadingMixIn | ||||
else: | ||||
if hasattr(os, "fork"): | ||||
_mixin = SocketServer.ForkingMixIn | ||||
else: | ||||
|
r3673 | class _mixin: | ||
pass | ||||
|
r2355 | |||
class MercurialHTTPServer(object, _mixin, BaseHTTPServer.HTTPServer): | ||||
|
r4516 | |||
|
r4130 | # SO_REUSEADDR has broken semantics on windows | ||
if os.name == 'nt': | ||||
allow_reuse_address = 0 | ||||
|
r4516 | |||
|
r2355 | def __init__(self, *args, **kargs): | ||
BaseHTTPServer.HTTPServer.__init__(self, *args, **kargs) | ||||
self.accesslog = accesslog | ||||
self.errorlog = errorlog | ||||
|
r2650 | self.daemon_threads = True | ||
|
r4245 | def make_handler(): | ||
if webdir_conf: | ||||
hgwebobj = hgwebdir(webdir_conf, ui) | ||||
elif repo is not None: | ||||
hgwebobj = hgweb(hg.repository(repo.ui, repo.root)) | ||||
else: | ||||
|
r7637 | raise error.RepoError(_("There is no Mercurial repository" | ||
" here (.hg not found)")) | ||||
|
r4245 | return hgwebobj | ||
|
r5566 | self.application = make_handler() | ||
|
r2355 | |||
|
r4860 | if ssl_cert: | ||
try: | ||||
from OpenSSL import SSL | ||||
ctx = SSL.Context(SSL.SSLv23_METHOD) | ||||
except ImportError: | ||||
|
r6953 | raise util.Abort(_("SSL support is unavailable")) | ||
|
r4860 | ctx.use_privatekey_file(ssl_cert) | ||
ctx.use_certificate_file(ssl_cert) | ||||
sock = socket.socket(self.address_family, self.socket_type) | ||||
self.socket = SSL.Connection(ctx, sock) | ||||
self.server_bind() | ||||
self.server_activate() | ||||
|
r6262 | self.addr, self.port = self.socket.getsockname()[0:2] | ||
self.prefix = prefix | ||||
self.fqaddr = socket.getfqdn(address) | ||||
|
r2355 | class IPv6HTTPServer(MercurialHTTPServer): | ||
address_family = getattr(socket, 'AF_INET6', None) | ||||
def __init__(self, *args, **kwargs): | ||||
if self.address_family is None: | ||||
|
r7928 | raise error.RepoError(_('IPv6 is not available on this system')) | ||
|
r2507 | super(IPv6HTTPServer, self).__init__(*args, **kwargs) | ||
|
r2355 | |||
|
r4860 | if ssl_cert: | ||
handler = _shgwebhandler | ||||
else: | ||||
handler = _hgwebhandler | ||||
|
r3628 | try: | ||
if use_ipv6: | ||||
|
r4860 | return IPv6HTTPServer((address, port), handler) | ||
|
r3628 | else: | ||
|
r4860 | return MercurialHTTPServer((address, port), handler) | ||
|
r3628 | except socket.error, inst: | ||
|
r6262 | raise util.Abort(_("cannot start server at '%s:%d': %s") | ||
% (address, port, inst.args[1])) | ||||