server.py
320 lines
| 11.2 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 | # | ||
|
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. | ||
|
r2355 | |||
|
r4016 | import os, sys, errno, urllib, BaseHTTPServer, socket, SocketServer, traceback | ||
|
r10905 | from mercurial import util, error | ||
|
r13570 | from mercurial.hgweb import common | ||
|
r7225 | from mercurial.i18n import _ | ||
|
r2355 | |||
def _splitURI(uri): | ||||
|
r17427 | """Return path and query that has been split from uri | ||
|
r2355 | |||
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) | ||||
|
r12783 | class _httprequesthandler(BaseHTTPServer.BaseHTTPRequestHandler): | ||
|
r4870 | |||
url_scheme = 'http' | ||||
|
r4957 | |||
|
r12783 | @staticmethod | ||
def preparehttpserver(httpserver, ssl_cert): | ||||
"""Prepare .socket of new HTTPServer instance""" | ||||
pass | ||||
|
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 | |||
|
r14093 | def log_request(self, code='-', size='-'): | ||
xheaders = [h for h in self.headers.items() if h[0].startswith('x-')] | ||||
self.log_message('"%s" %s %s%s', | ||||
self.requestline, str(code), str(size), | ||||
''.join([' %s:%s' % h for h in sorted(xheaders)])) | ||||
|
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() | ||
|
r13443 | except Exception: | ||
|
r4015 | self._start_response("500 Internal Server Error", []) | ||
self._write("Internal Server Error") | ||||
tb = "".join(traceback.format_exception(*sys.exc_info())) | ||||
|
r8663 | 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 | ||
|
r13570 | if env.get('HTTP_EXPECT', '').lower() == '100-continue': | ||
self.rfile = common.continuereader(self.rfile, self.wfile.write) | ||||
|
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: | ||||
|
r8663 | raise AssertionError("Sending headers before " | ||
"start_response() called") | ||||
|
r2506 | 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: | ||||
|
r8663 | raise AssertionError("Content-length header sent, but more " | ||
"bytes than specified are being written.") | ||||
|
r2508 | self.length = self.length - len(data) | ||
|
r2506 | self.wfile.write(data) | ||
self.wfile.flush() | ||||
|
r2355 | |||
|
r12783 | class _httprequesthandleropenssl(_httprequesthandler): | ||
"""HTTPS handler based on pyOpenSSL""" | ||||
|
r4870 | |||
url_scheme = 'https' | ||||
|
r4957 | |||
|
r12783 | @staticmethod | ||
def preparehttpserver(httpserver, ssl_cert): | ||||
try: | ||||
import OpenSSL | ||||
OpenSSL.SSL.Context | ||||
except ImportError: | ||||
raise util.Abort(_("SSL support is unavailable")) | ||||
ctx = OpenSSL.SSL.Context(OpenSSL.SSL.SSLv23_METHOD) | ||||
ctx.use_privatekey_file(ssl_cert) | ||||
ctx.use_certificate_file(ssl_cert) | ||||
sock = socket.socket(httpserver.address_family, httpserver.socket_type) | ||||
httpserver.socket = OpenSSL.SSL.Connection(ctx, sock) | ||||
httpserver.server_bind() | ||||
httpserver.server_activate() | ||||
|
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): | ||||
|
r12783 | import OpenSSL | ||
|
r4860 | try: | ||
|
r12783 | _httprequesthandler.do_write(self) | ||
except OpenSSL.SSL.SysCallError, inst: | ||||
|
r4860 | if inst.args[0] != errno.EPIPE: | ||
raise | ||||
def handle_one_request(self): | ||||
|
r12783 | import OpenSSL | ||
|
r4860 | try: | ||
|
r12783 | _httprequesthandler.handle_one_request(self) | ||
except (OpenSSL.SSL.SysCallError, OpenSSL.SSL.ZeroReturnError): | ||||
|
r4860 | self.close_connection = True | ||
pass | ||||
|
r12784 | class _httprequesthandlerssl(_httprequesthandler): | ||
"""HTTPS handler based on Pythons ssl module (introduced in 2.6)""" | ||||
url_scheme = 'https' | ||||
@staticmethod | ||||
def preparehttpserver(httpserver, ssl_cert): | ||||
try: | ||||
import ssl | ||||
ssl.wrap_socket | ||||
except ImportError: | ||||
raise util.Abort(_("SSL support is unavailable")) | ||||
httpserver.socket = ssl.wrap_socket(httpserver.socket, server_side=True, | ||||
|
r12797 | certfile=ssl_cert, ssl_version=ssl.PROTOCOL_SSLv23) | ||
|
r12784 | |||
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) | ||||
|
r10639 | try: | ||
from threading import activeCount | ||||
|
r15223 | activeCount() # silence pyflakes | ||
|
r10639 | _mixin = SocketServer.ThreadingMixIn | ||
except ImportError: | ||||
|
r14957 | if util.safehasattr(os, "fork"): | ||
|
r10639 | _mixin = SocketServer.ForkingMixIn | ||
else: | ||||
|
r14764 | class _mixin(object): | ||
|
r10639 | pass | ||
|
r10643 | def openlog(opt, default): | ||
if opt and opt != '-': | ||||
return open(opt, 'a') | ||||
return default | ||||
class MercurialHTTPServer(object, _mixin, BaseHTTPServer.HTTPServer): | ||||
# SO_REUSEADDR has broken semantics on windows | ||||
if os.name == 'nt': | ||||
allow_reuse_address = 0 | ||||
def __init__(self, ui, app, addr, handler, **kwargs): | ||||
BaseHTTPServer.HTTPServer.__init__(self, addr, handler, **kwargs) | ||||
self.daemon_threads = True | ||||
self.application = app | ||||
|
r2355 | |||
|
r12783 | handler.preparehttpserver(self, ui.config('web', 'certificate')) | ||
|
r10643 | |||
prefix = ui.config('web', 'prefix', '') | ||||
if prefix: | ||||
prefix = '/' + prefix.strip('/') | ||||
self.prefix = prefix | ||||
alog = openlog(ui.config('web', 'accesslog', '-'), sys.stdout) | ||||
elog = openlog(ui.config('web', 'errorlog', '-'), sys.stderr) | ||||
self.accesslog = alog | ||||
self.errorlog = elog | ||||
self.addr, self.port = self.socket.getsockname()[0:2] | ||||
self.fqaddr = socket.getfqdn(addr[0]) | ||||
class IPv6HTTPServer(MercurialHTTPServer): | ||||
address_family = getattr(socket, 'AF_INET6', None) | ||||
def __init__(self, *args, **kwargs): | ||||
if self.address_family is None: | ||||
raise error.RepoError(_('IPv6 is not available on this system')) | ||||
super(IPv6HTTPServer, self).__init__(*args, **kwargs) | ||||
|
r10644 | def create_server(ui, app): | ||
|
r2355 | |||
|
r10644 | if ui.config('web', 'certificate'): | ||
|
r12784 | if sys.version_info >= (2, 6): | ||
handler = _httprequesthandlerssl | ||||
else: | ||||
handler = _httprequesthandleropenssl | ||||
|
r4860 | else: | ||
|
r12783 | handler = _httprequesthandler | ||
|
r4860 | |||
|
r10644 | if ui.configbool('web', 'ipv6'): | ||
|
r10641 | cls = IPv6HTTPServer | ||
else: | ||||
cls = MercurialHTTPServer | ||||
|
r8224 | # ugly hack due to python issue5853 (for threaded use) | ||
import mimetypes; mimetypes.init() | ||||
|
r10644 | address = ui.config('web', 'address', '') | ||
|
r12076 | port = util.getport(ui.config('web', 'port', 8000)) | ||
|
r3628 | try: | ||
|
r10644 | return cls(ui, app, (address, port), handler) | ||
|
r3628 | except socket.error, inst: | ||
|
r6262 | raise util.Abort(_("cannot start server at '%s:%d': %s") | ||
% (address, port, inst.args[1])) | ||||