1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
#!/usr/bin/env python
"""$URL: svn+ssh://svn.mems-exchange.org/repos/trunk/quixote/server/simple_server.py $
$Id: simple_server.py 27684 2005-11-10 15:25:17Z dbinger $
A simple, single threaded, synchronous HTTP server.
"""
import sys
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
import urllib
import quixote
from quixote import get_publisher
from quixote.util import import_object
class HTTPRequestHandler(BaseHTTPRequestHandler):
required_cgi_environment = {}
def get_cgi_env(self, method):
env = dict(
SERVER_SOFTWARE="Quixote/%s" % quixote.__version__,
SERVER_NAME=self.server.server_name,
GATEWAY_INTERFACE='CGI/1.1',
SERVER_PROTOCOL=self.protocol_version,
SERVER_PORT=str(self.server.server_port),
REQUEST_METHOD=method,
REMOTE_ADDR=self.client_address[0],
SCRIPT_NAME='')
if '?' in self.path:
env['PATH_INFO'], env['QUERY_STRING'] = self.path.split('?', 1)
else:
env['PATH_INFO'] = self.path
env['PATH_INFO'] = urllib.unquote(env['PATH_INFO'])
if self.headers.typeheader is None:
env['CONTENT_TYPE'] = self.headers.type
else:
env['CONTENT_TYPE'] = self.headers.typeheader
env['CONTENT_LENGTH'] = self.headers.getheader('content-length') or "0"
for name, value in self.headers.items():
header_name = 'HTTP_' + name.upper().replace('-', '_')
env[header_name] = value
accept = []
for line in self.headers.getallmatchingheaders('accept'):
if line[:1] in "\t\n\r ":
accept.append(line.strip())
else:
accept = accept + line[7:].split(',')
env['HTTP_ACCEPT'] = ','.join(accept)
co = filter(None, self.headers.getheaders('cookie'))
if co:
env['HTTP_COOKIE'] = ', '.join(co)
env.update(self.required_cgi_environment)
return env
def process(self, env, include_body=True):
response = get_publisher().process(self.rfile, env)
try:
self.send_response(response.get_status_code(),
response.get_reason_phrase())
response.write(self.wfile, include_status=False,
include_body=include_body)
except IOError, err:
print "IOError while sending response ignored: %s" % err
def do_POST(self):
return self.process(self.get_cgi_env('POST'))
def do_GET(self):
return self.process(self.get_cgi_env('GET'))
def do_HEAD(self):
return self.process(self.get_cgi_env('HEAD'), include_body=False)
def send_response(self, code, message=None):
"""
Copied, with regret, from BaseHTTPRequestHandler, except that the line
that adds the 'Date' header is removed to avoid duplicating the one
that Quixote adds.
"""
self.log_request(code)
if message is None:
if code in self.responses:
message = self.responses[code][0]
else:
message = ''
if self.request_version != 'HTTP/0.9':
self.wfile.write("%s %d %s\r\n" %
(self.protocol_version, code, message))
self.send_header('Server', self.version_string())
def run(create_publisher, host='', port=80, https=False):
"""Runs a simple, single threaded, synchronous HTTP server that
publishes a Quixote application.
"""
if https:
HTTPRequestHandler.required_cgi_environment['HTTPS'] = 'on'
httpd = HTTPServer((host, port), HTTPRequestHandler)
def handle_error(request, client_address):
HTTPServer.handle_error(httpd, request, client_address)
if sys.exc_info()[0] is SystemExit:
raise
httpd.handle_error = handle_error
publisher = create_publisher()
httpd.serve_forever()
if __name__ == '__main__':
from quixote.server.util import get_server_parser
parser = get_server_parser(run.__doc__)
parser.add_option(
'--https', dest="https", default=False, action="store_true",
help=("Force the scheme for all requests to be https. "
"Not that this is for running the simple server "
"through a proxy or tunnel that provides real SSL "
"support. The simple server itself does not. "))
(options, args) = parser.parse_args()
run(import_object(options.factory), host=options.host, port=options.port,
https=options.https)
|
