13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
from SimpleHTTPServer import SimpleHTTPRequestHandler
24
import SimpleHTTPServer
31
from bzrlib.transport import Server
32
from bzrlib.transport.local import LocalURLServer
35
class WebserverNotAvailable(Exception):
38
from bzrlib.tests import test_server
39
from bzrlib.transport import local
39
42
class BadWebserverPath(ValueError):
41
44
return 'path %s is not in %s' % self.args
44
class TestingHTTPRequestHandler(SimpleHTTPRequestHandler):
47
class TestingHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
45
48
"""Handles one request.
47
A TestingHTTPRequestHandler is instantiated for every request
48
received by the associated server.
50
A TestingHTTPRequestHandler is instantiated for every request received by
51
the associated server. Note that 'request' here is inherited from the base
52
TCPServer class, for the HTTP server it is really a connection which itself
53
will handle one or several HTTP requests.
55
# Default protocol version
56
protocol_version = 'HTTP/1.1'
58
# The Message-like class used to parse the request headers
59
MessageClass = httplib.HTTPMessage
62
SimpleHTTPServer.SimpleHTTPRequestHandler.setup(self)
63
self._cwd = self.server._home_dir
64
tcs = self.server.test_case_server
65
if tcs.protocol_version is not None:
66
# If the test server forced a protocol version, use it
67
self.protocol_version = tcs.protocol_version
51
69
def log_message(self, format, *args):
52
70
tcs = self.server.test_case_server
57
75
self.headers.get('referer', '-'),
58
76
self.headers.get('user-agent', '-'))
79
SimpleHTTPServer.SimpleHTTPRequestHandler.handle(self)
80
# Some client (pycurl, I'm looking at you) are more picky than others
81
# and require that the socket itself is closed
82
# (SocketServer.StreamRequestHandler only close the two associated
84
self.connection.close()
60
86
def handle_one_request(self):
61
87
"""Handle a single HTTP request.
63
You normally don't need to override this method; see the class
64
__doc__ string for information on how to handle specific HTTP
65
commands such as GET and POST.
89
We catch all socket errors occurring when the client close the
90
connection early to avoid polluting the test results.
68
for i in xrange(1,11): # Don't try more than 10 times
70
self.raw_requestline = self.rfile.readline()
71
except socket.error, e:
72
if e.args[0] in (errno.EAGAIN, errno.EWOULDBLOCK):
73
# omitted for now because some tests look at the log of
74
# the server and expect to see no errors. see recent
75
# email thread. -- mbp 20051021.
76
## self.log_message('EAGAIN (%d) while reading from raw_requestline' % i)
93
self._handle_one_request()
94
except socket.error, e:
95
# Any socket error should close the connection, but some errors are
96
# due to the client closing early and we don't want to pollute test
97
# results, so we raise only the others.
98
self.close_connection = 1
100
or e.args[0] not in (errno.EPIPE, errno.ECONNRESET,
101
errno.ECONNABORTED, errno.EBADF)):
82
if not self.raw_requestline:
83
self.close_connection = 1
85
if not self.parse_request(): # An error code has been sent, just exit
87
mname = 'do_' + self.command
88
if getattr(self, mname, None) is None:
89
self.send_error(501, "Unsupported method (%r)" % self.command)
91
method = getattr(self, mname)
104
error_content_type = 'text/plain'
105
error_message_format = '''\
106
Error code: %(code)s.
107
Message: %(message)s.
110
def send_error(self, code, message=None):
111
"""Send and log an error reply.
113
We redefine the python-provided version to be able to set a
114
``Content-Length`` header as some http/1.1 clients complain otherwise
117
:param code: The HTTP error code.
119
:param message: The explanation of the error code, Defaults to a short
125
message = self.responses[code][0]
128
self.log_error("code %d, message %s", code, message)
129
content = (self.error_message_format %
130
{'code': code, 'message': message})
131
self.send_response(code, message)
132
self.send_header("Content-Type", self.error_content_type)
133
self.send_header("Content-Length", "%d" % len(content))
134
self.send_header('Connection', 'close')
136
if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
137
self.wfile.write(content)
139
def _handle_one_request(self):
140
SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
94
142
_range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
95
143
_tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
128
176
return tail, ranges
178
def _header_line_length(self, keyword, value):
179
header_line = '%s: %s\r\n' % (keyword, value)
180
return len(header_line)
183
"""Overrides base implementation to work around a bug in python2.5."""
184
path = self.translate_path(self.path)
185
if os.path.isdir(path) and not self.path.endswith('/'):
186
# redirect browser - doing basically what apache does when
187
# DirectorySlash option is On which is quite common (braindead, but
189
self.send_response(301)
190
self.send_header("Location", self.path + "/")
191
# Indicates that the body is empty for HTTP/1.1 clients
192
self.send_header('Content-Length', '0')
196
return SimpleHTTPServer.SimpleHTTPRequestHandler.send_head(self)
130
198
def send_range_content(self, file, start, length):
132
200
self.wfile.write(file.read(length))
147
215
def get_multiple_ranges(self, file, file_size, ranges):
148
216
self.send_response(206)
149
217
self.send_header('Accept-Ranges', 'bytes')
150
boundary = "%d" % random.randint(0,0x7FFFFFFF)
151
self.send_header("Content-Type",
152
"multipart/byteranges; boundary=%s" % boundary)
218
boundary = '%d' % random.randint(0,0x7FFFFFFF)
219
self.send_header('Content-Type',
220
'multipart/byteranges; boundary=%s' % boundary)
221
boundary_line = '--%s\r\n' % boundary
222
# Calculate the Content-Length
224
for (start, end) in ranges:
225
content_length += len(boundary_line)
226
content_length += self._header_line_length(
227
'Content-type', 'application/octet-stream')
228
content_length += self._header_line_length(
229
'Content-Range', 'bytes %d-%d/%d' % (start, end, file_size))
230
content_length += len('\r\n') # end headers
231
content_length += end - start + 1
232
content_length += len(boundary_line)
233
self.send_header('Content-length', content_length)
153
234
self.end_headers()
236
# Send the multipart body
154
237
for (start, end) in ranges:
155
self.wfile.write("--%s\r\n" % boundary)
156
self.send_header("Content-type", 'application/octet-stream')
157
self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
238
self.wfile.write(boundary_line)
239
self.send_header('Content-type', 'application/octet-stream')
240
self.send_header('Content-Range', 'bytes %d-%d/%d'
241
% (start, end, file_size))
160
242
self.end_headers()
161
243
self.send_range_content(file, start, end - start + 1)
162
self.wfile.write("--%s\r\n" % boundary)
245
self.wfile.write(boundary_line)
164
247
def do_GET(self):
165
248
"""Serve a GET request.
167
250
Handles the Range header.
253
self.server.test_case_server.GET_request_nb += 1
170
255
path = self.translate_path(self.path)
171
256
ranges_header_value = self.headers.get('Range')
172
257
if ranges_header_value is None or os.path.isdir(path):
173
258
# Let the mother class handle most cases
174
return SimpleHTTPRequestHandler.do_GET(self)
259
return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
177
262
# Always read in binary mode. Opening files in text
178
263
# mode may cause newline translations, making the
179
264
# actual size of the content transmitted *less* than
180
265
# the content-length!
181
file = open(path, 'rb')
183
268
self.send_error(404, "File not found")
186
file_size = os.fstat(file.fileno())[6]
271
file_size = os.fstat(f.fileno())[6]
187
272
tail, ranges = self.parse_ranges(ranges_header_value)
188
273
# Normalize tail into ranges
248
333
return self._translate_path(path)
250
335
def _translate_path(self, path):
251
return SimpleHTTPRequestHandler.translate_path(self, path)
253
if sys.platform == 'win32':
254
# On win32 you cannot access non-ascii filenames without
255
# decoding them into unicode first.
256
# However, under Linux, you can access bytestream paths
257
# without any problems. If this function was always active
258
# it would probably break tests when LANG=C was set
259
def _translate_path(self, path):
260
"""Translate a /-separated PATH to the local filename syntax.
262
For bzr, all url paths are considered to be utf8 paths.
263
On Linux, you can access these paths directly over the bytestream
264
request, but on win32, you must decode them, and access them
267
# abandon query parameters
268
path = urlparse.urlparse(path)[2]
269
path = posixpath.normpath(urllib.unquote(path))
270
path = path.decode('utf-8')
271
words = path.split('/')
272
words = filter(None, words)
336
"""Translate a /-separated PATH to the local filename syntax.
338
Note that we're translating http URLs here, not file URLs.
339
The URL root location is the server's startup directory.
340
Components that mean special things to the local file system
341
(e.g. drive or directory names) are ignored. (XXX They should
342
probably be diagnosed.)
344
Override from python standard library to stop it calling os.getcwd()
346
# abandon query parameters
347
path = urlparse.urlparse(path)[2]
348
path = posixpath.normpath(urllib.unquote(path))
349
path = path.decode('utf-8')
350
words = path.split('/')
351
words = filter(None, words)
353
for num, word in enumerate(words):
275
355
drive, word = os.path.splitdrive(word)
276
head, word = os.path.split(word)
277
if word in (os.curdir, os.pardir): continue
278
path = os.path.join(path, word)
282
class TestingHTTPServer(BaseHTTPServer.HTTPServer):
284
def __init__(self, server_address, RequestHandlerClass,
286
BaseHTTPServer.HTTPServer.__init__(self, server_address,
356
head, word = os.path.split(word)
357
if word in (os.curdir, os.pardir): continue
358
path = os.path.join(path, word)
362
class TestingHTTPServerMixin:
364
def __init__(self, test_case_server):
288
365
# test_case_server can be used to communicate between the
289
366
# tests and the server (or the request handler and the
290
367
# server), allowing dynamic behaviors to be defined from
291
368
# the tests cases.
292
369
self.test_case_server = test_case_server
295
class HttpServer(Server):
370
self._home_dir = test_case_server._home_dir
373
class TestingHTTPServer(test_server.TestingTCPServer, TestingHTTPServerMixin):
375
def __init__(self, server_address, request_handler_class,
377
test_server.TestingTCPServer.__init__(self, server_address,
378
request_handler_class)
379
TestingHTTPServerMixin.__init__(self, test_case_server)
382
class TestingThreadingHTTPServer(test_server.TestingThreadingTCPServer,
383
TestingHTTPServerMixin):
384
"""A threading HTTP test server for HTTP 1.1.
386
Since tests can initiate several concurrent connections to the same http
387
server, we need an independent connection for each of them. We achieve that
388
by spawning a new thread for each connection.
390
def __init__(self, server_address, request_handler_class,
392
test_server.TestingThreadingTCPServer.__init__(self, server_address,
393
request_handler_class)
394
TestingHTTPServerMixin.__init__(self, test_case_server)
397
class HttpServer(test_server.TestingTCPServerInAThread):
296
398
"""A test server for http transports.
298
400
Subclasses can provide a specific request handler.
403
# The real servers depending on the protocol
404
http_server_class = {'HTTP/1.0': TestingHTTPServer,
405
'HTTP/1.1': TestingThreadingHTTPServer,
301
408
# Whether or not we proxy the requests (see
302
409
# TestingHTTPRequestHandler.translate_path).
303
410
proxy_requests = False
305
412
# used to form the url that connects to this server
306
413
_url_protocol = 'http'
308
# Subclasses can provide a specific request handler
309
def __init__(self, request_handler=TestingHTTPRequestHandler):
310
Server.__init__(self)
311
self.request_handler = request_handler
415
def __init__(self, request_handler=TestingHTTPRequestHandler,
416
protocol_version=None):
419
:param request_handler: a class that will be instantiated to handle an
420
http connection (one or several requests).
422
:param protocol_version: if specified, will override the protocol
423
version of the request handler.
425
# Depending on the protocol version, we will create the approriate
427
if protocol_version is None:
428
# Use the request handler one
429
proto_vers = request_handler.protocol_version
431
# Use our own, it will be used to override the request handler
433
proto_vers = protocol_version
434
# Get the appropriate server class for the required protocol
435
serv_cls = self.http_server_class.get(proto_vers, None)
437
raise httplib.UnknownProtocol(proto_vers)
312
438
self.host = 'localhost'
316
def _get_httpd(self):
317
if self._httpd is None:
318
self._httpd = TestingHTTPServer((self.host, self.port),
319
self.request_handler,
321
host, self.port = self._httpd.socket.getsockname()
324
def _http_start(self):
325
httpd = self._get_httpd()
326
self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
329
self._http_starting.release()
330
httpd.socket.settimeout(0.1)
332
while self._http_running:
334
httpd.handle_request()
335
except socket.timeout:
440
super(HttpServer, self).__init__((self.host, self.port),
443
self.protocol_version = proto_vers
444
# Allows tests to verify number of GET requests issued
445
self.GET_request_nb = 0
446
self._http_base_url = None
449
def create_server(self):
450
return self.server_class(
451
(self.host, self.port), self.request_handler_class, self)
338
453
def _get_remote_url(self, path):
339
454
path_parts = path.split(os.path.sep)
351
466
"""Capture Server log output."""
352
467
self.logs.append(format % args)
354
def setUp(self, backing_transport_server=None):
355
"""See bzrlib.transport.Server.setUp.
469
def start_server(self, backing_transport_server=None):
470
"""See bzrlib.transport.Server.start_server.
357
472
:param backing_transport_server: The transport that requests over this
358
473
protocol should be forwarded to. Note that this is currently not
359
474
supported for HTTP.
361
476
# XXX: TODO: make the server back onto vfs_server rather than local
363
assert backing_transport_server is None or \
364
isinstance(backing_transport_server, LocalURLServer), \
365
"HTTPServer currently assumes local transport, got %s" % \
366
backing_transport_server
478
if not (backing_transport_server is None
479
or isinstance(backing_transport_server,
480
test_server.LocalURLServer)):
481
raise AssertionError(
482
"HTTPServer currently assumes local transport, got %s" %
483
backing_transport_server)
367
484
self._home_dir = os.getcwdu()
368
485
self._local_path_parts = self._home_dir.split(os.path.sep)
369
self._http_starting = threading.Lock()
370
self._http_starting.acquire()
371
self._http_running = True
372
self._http_base_url = None
373
self._http_thread = threading.Thread(target=self._http_start)
374
self._http_thread.setDaemon(True)
375
self._http_thread.start()
376
# Wait for the server thread to start (i.e release the lock)
377
self._http_starting.acquire()
378
self._http_starting.release()
382
"""See bzrlib.transport.Server.tearDown."""
383
self._http_running = False
384
self._http_thread.join()
488
super(HttpServer, self).start_server()
489
self._http_base_url = '%s://%s:%s/' % (
490
self._url_protocol, self.host, self.port)
386
492
def get_url(self):
387
493
"""See bzrlib.transport.Server.get_url."""
added
removed
bzrlib/tests/http_server.py
