42
41
return 'path %s is not in %s' % self.args
45
class TestingHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
44
class TestingHTTPRequestHandler(SimpleHTTPRequestHandler):
46
45
"""Handles one request.
48
A TestingHTTPRequestHandler is instantiated for every request received by
49
the associated server. Note that 'request' here is inherited from the base
50
TCPServer class, for the HTTP server it is really a connection which itself
51
will handle one or several HTTP requests.
47
A TestingHTTPRequestHandler is instantiated for every request
48
received by the associated server.
53
# Default protocol version
54
protocol_version = 'HTTP/1.1'
56
# The Message-like class used to parse the request headers
57
MessageClass = httplib.HTTPMessage
60
SimpleHTTPServer.SimpleHTTPRequestHandler.setup(self)
61
self._cwd = self.server._home_dir
62
tcs = self.server.test_case_server
63
if tcs.protocol_version is not None:
64
# If the test server forced a protocol version, use it
65
self.protocol_version = tcs.protocol_version
67
51
def log_message(self, format, *args):
68
52
tcs = self.server.test_case_server
80
64
connection early to avoid polluting the test results.
83
SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
67
self._handle_one_request()
84
68
except socket.error, e:
85
# Any socket error should close the connection, but some errors are
86
# due to the client closing early and we don't want to pollute test
87
# results, so we raise only the others.
70
and e.args[0] in (errno.EPIPE, errno.ECONNRESET,
71
errno.ECONNABORTED,)):
72
self.close_connection = 1
77
def _handle_one_request(self):
79
Request handling as defined in the base class.
81
You normally don't need to override this method; see the class
82
__doc__ string for information on how to handle specific HTTP
83
commands such as GET and POST.
85
On some platforms, notably OS X, a lot of EAGAIN (resource temporary
86
unavailable) occur. We retry silently at most 10 times.
88
for i in xrange(1,11): # Don't try more than 10 times
90
self.raw_requestline = self.rfile.readline()
91
except socket.error, e:
92
if e.args[0] in (errno.EAGAIN, errno.EWOULDBLOCK):
93
# omitted for now because some tests look at the log of
94
# the server and expect to see no errors. see recent
95
# email thread. -- mbp 20051021.
96
## self.log_message('EAGAIN (%d) while reading from raw_requestline' % i)
102
if not self.raw_requestline:
88
103
self.close_connection = 1
90
or e.args[0] not in (errno.EPIPE, errno.ECONNRESET,
91
errno.ECONNABORTED, errno.EBADF)):
105
if not self.parse_request(): # An error code has been sent, just exit
107
mname = 'do_' + self.command
108
if getattr(self, mname, None) is None:
109
self.send_error(501, "Unsupported method (%r)" % self.command)
111
method = getattr(self, mname)
94
114
_range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
95
115
_tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
167
167
def get_multiple_ranges(self, file, file_size, ranges):
168
168
self.send_response(206)
169
169
self.send_header('Accept-Ranges', 'bytes')
170
boundary = '%d' % random.randint(0,0x7FFFFFFF)
171
self.send_header('Content-Type',
172
'multipart/byteranges; boundary=%s' % boundary)
173
boundary_line = '--%s\r\n' % boundary
174
# Calculate the Content-Length
176
for (start, end) in ranges:
177
content_length += len(boundary_line)
178
content_length += self._header_line_length(
179
'Content-type', 'application/octet-stream')
180
content_length += self._header_line_length(
181
'Content-Range', 'bytes %d-%d/%d' % (start, end, file_size))
182
content_length += len('\r\n') # end headers
183
content_length += end - start # + 1
184
content_length += len(boundary_line)
185
self.send_header('Content-length', content_length)
170
boundary = "%d" % random.randint(0,0x7FFFFFFF)
171
self.send_header("Content-Type",
172
"multipart/byteranges; boundary=%s" % boundary)
186
173
self.end_headers()
188
# Send the multipart body
189
174
for (start, end) in ranges:
190
self.wfile.write(boundary_line)
191
self.send_header('Content-type', 'application/octet-stream')
192
self.send_header('Content-Range', 'bytes %d-%d/%d'
193
% (start, end, file_size))
175
self.wfile.write("--%s\r\n" % boundary)
176
self.send_header("Content-type", 'application/octet-stream')
177
self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
194
180
self.end_headers()
195
181
self.send_range_content(file, start, end - start + 1)
197
self.wfile.write(boundary_line)
182
self.wfile.write("--%s\r\n" % boundary)
199
184
def do_GET(self):
200
185
"""Serve a GET request.
202
187
Handles the Range header.
205
self.server.test_case_server.GET_request_nb += 1
207
190
path = self.translate_path(self.path)
208
191
ranges_header_value = self.headers.get('Range')
209
192
if ranges_header_value is None or os.path.isdir(path):
210
193
# Let the mother class handle most cases
211
return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
194
return SimpleHTTPRequestHandler.do_GET(self)
214
197
# Always read in binary mode. Opening files in text
285
268
return self._translate_path(path)
287
270
def _translate_path(self, path):
288
"""Translate a /-separated PATH to the local filename syntax.
290
Note that we're translating http URLs here, not file URLs.
291
The URL root location is the server's startup directory.
292
Components that mean special things to the local file system
293
(e.g. drive or directory names) are ignored. (XXX They should
294
probably be diagnosed.)
296
Override from python standard library to stop it calling os.getcwd()
298
# abandon query parameters
299
path = urlparse.urlparse(path)[2]
300
path = posixpath.normpath(urllib.unquote(path))
301
path = path.decode('utf-8')
302
words = path.split('/')
303
words = filter(None, words)
305
for num, word in enumerate(words):
271
return SimpleHTTPRequestHandler.translate_path(self, path)
273
if sys.platform == 'win32':
274
# On win32 you cannot access non-ascii filenames without
275
# decoding them into unicode first.
276
# However, under Linux, you can access bytestream paths
277
# without any problems. If this function was always active
278
# it would probably break tests when LANG=C was set
279
def _translate_path(self, path):
280
"""Translate a /-separated PATH to the local filename syntax.
282
For bzr, all url paths are considered to be utf8 paths.
283
On Linux, you can access these paths directly over the bytestream
284
request, but on win32, you must decode them, and access them
287
# abandon query parameters
288
path = urlparse.urlparse(path)[2]
289
path = posixpath.normpath(urllib.unquote(path))
290
path = path.decode('utf-8')
291
words = path.split('/')
292
words = filter(None, words)
307
295
drive, word = os.path.splitdrive(word)
308
head, word = os.path.split(word)
309
if word in (os.curdir, os.pardir): continue
310
path = os.path.join(path, word)
314
class TestingHTTPServerMixin:
316
def __init__(self, test_case_server):
296
head, word = os.path.split(word)
297
if word in (os.curdir, os.pardir): continue
298
path = os.path.join(path, word)
302
class TestingHTTPServer(BaseHTTPServer.HTTPServer):
304
def __init__(self, server_address, RequestHandlerClass,
306
BaseHTTPServer.HTTPServer.__init__(self, server_address,
317
308
# test_case_server can be used to communicate between the
318
309
# tests and the server (or the request handler and the
319
310
# server), allowing dynamic behaviors to be defined from
320
311
# the tests cases.
321
312
self.test_case_server = test_case_server
322
self._home_dir = test_case_server._home_dir
325
"""Called to clean-up the server.
327
Since the server may be (surely is, even) in a blocking listen, we
328
shutdown its socket before closing it.
330
# Note that is this executed as part of the implicit tear down in the
331
# main thread while the server runs in its own thread. The clean way
332
# to tear down the server is to instruct him to stop accepting
333
# connections and wait for the current connection(s) to end
334
# naturally. To end the connection naturally, the http transports
335
# should close their socket when they do not need to talk to the
336
# server anymore. This happens naturally during the garbage collection
337
# phase of the test transport objetcs (the server clients), so we
338
# don't have to worry about them. So, for the server, we must tear
339
# down here, from the main thread, when the test have ended. Note
340
# that since the server is in a blocking operation and since python
341
# use select internally, shutting down the socket is reliable and
344
self.socket.shutdown(socket.SHUT_RDWR)
345
except socket.error, e:
346
# WSAENOTCONN (10057) 'Socket is not connected' is harmless on
347
# windows (occurs before the first connection attempt
349
if not len(e.args) or e.args[0] != 10057:
351
# Let the server properly close the socket
355
class TestingHTTPServer(SocketServer.TCPServer, TestingHTTPServerMixin):
357
def __init__(self, server_address, request_handler_class,
359
TestingHTTPServerMixin.__init__(self, test_case_server)
360
SocketServer.TCPServer.__init__(self, server_address,
361
request_handler_class)
364
class TestingThreadingHTTPServer(SocketServer.ThreadingTCPServer,
365
TestingHTTPServerMixin):
366
"""A threading HTTP test server for HTTP 1.1.
368
Since tests can initiate several concurrent connections to the same http
369
server, we need an independent connection for each of them. We achieve that
370
by spawning a new thread for each connection.
373
def __init__(self, server_address, request_handler_class,
375
TestingHTTPServerMixin.__init__(self, test_case_server)
376
SocketServer.ThreadingTCPServer.__init__(self, server_address,
377
request_handler_class)
378
# Decides how threads will act upon termination of the main
379
# process. This is prophylactic as we should not leave the threads
381
self.daemon_threads = True
384
class HttpServer(transport.Server):
315
class HttpServer(Server):
385
316
"""A test server for http transports.
387
318
Subclasses can provide a specific request handler.
390
# The real servers depending on the protocol
391
http_server_class = {'HTTP/1.0': TestingHTTPServer,
392
'HTTP/1.1': TestingThreadingHTTPServer,
395
321
# Whether or not we proxy the requests (see
396
322
# TestingHTTPRequestHandler.translate_path).
397
323
proxy_requests = False
399
325
# used to form the url that connects to this server
400
326
_url_protocol = 'http'
402
def __init__(self, request_handler=TestingHTTPRequestHandler,
403
protocol_version=None):
406
:param request_handler: a class that will be instantiated to handle an
407
http connection (one or several requests).
409
:param protocol_version: if specified, will override the protocol
410
version of the request handler.
412
transport.Server.__init__(self)
328
# Subclasses can provide a specific request handler
329
def __init__(self, request_handler=TestingHTTPRequestHandler):
330
Server.__init__(self)
413
331
self.request_handler = request_handler
414
332
self.host = 'localhost'
416
334
self._httpd = None
417
self.protocol_version = protocol_version
418
# Allows tests to verify number of GET requests issued
419
self.GET_request_nb = 0
421
336
def _get_httpd(self):
422
337
if self._httpd is None:
423
rhandler = self.request_handler
424
# Depending on the protocol version, we will create the approriate
426
if self.protocol_version is None:
427
# Use the request handler one
428
proto_vers = rhandler.protocol_version
430
# Use our own, it will be used to override the request handler
432
proto_vers = self.protocol_version
433
# Create the appropriate server for the required protocol
434
serv_cls = self.http_server_class.get(proto_vers, None)
436
raise httplib.UnknownProtocol(proto_vers)
438
self._httpd = serv_cls((self.host, self.port), rhandler, self)
338
self._httpd = TestingHTTPServer((self.host, self.port),
339
self.request_handler,
439
341
host, self.port = self._httpd.socket.getsockname()
440
342
return self._httpd
442
344
def _http_start(self):
443
"""Server thread main entry point. """
444
self._http_running = False
447
httpd = self._get_httpd()
448
self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
449
self.host, self.port)
450
self._http_running = True
452
# Whatever goes wrong, we save the exception for the main
453
# thread. Note that since we are running in a thread, no signal
454
# can be received, so we don't care about KeyboardInterrupt.
455
self._http_exception = sys.exc_info()
457
# Release the lock or the main thread will block and the whole
459
self._http_starting.release()
345
httpd = self._get_httpd()
346
self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
349
httpd.socket.settimeout(0.1)
350
self._http_starting.release()
461
# From now on, exceptions are taken care of by the
462
# SocketServer.BaseServer or the request handler.
463
352
while self._http_running:
465
# Really an HTTP connection but the python framework is generic
466
# and call them requests
467
354
httpd.handle_request()
468
355
except socket.timeout:
494
381
# XXX: TODO: make the server back onto vfs_server rather than local
496
if not (backing_transport_server is None or \
497
isinstance(backing_transport_server, local.LocalURLServer)):
498
raise AssertionError(
499
"HTTPServer currently assumes local transport, got %s" % \
500
backing_transport_server)
383
assert backing_transport_server is None or \
384
isinstance(backing_transport_server, LocalURLServer), \
385
"HTTPServer currently assumes local transport, got %s" % \
386
backing_transport_server
501
387
self._home_dir = os.getcwdu()
502
388
self._local_path_parts = self._home_dir.split(os.path.sep)
389
self._http_starting = threading.Lock()
390
self._http_starting.acquire()
391
self._http_running = True
503
392
self._http_base_url = None
505
# Create the server thread
506
self._http_starting = threading.Lock()
507
self._http_starting.acquire()
508
393
self._http_thread = threading.Thread(target=self._http_start)
509
394
self._http_thread.setDaemon(True)
510
self._http_exception = None
511
395
self._http_thread.start()
513
396
# Wait for the server thread to start (i.e release the lock)
514
397
self._http_starting.acquire()
516
if self._http_exception is not None:
517
# Something went wrong during server start
518
exc_class, exc_value, exc_tb = self._http_exception
519
raise exc_class, exc_value, exc_tb
520
398
self._http_starting.release()
523
401
def tearDown(self):
524
402
"""See bzrlib.transport.Server.tearDown."""
525
self._httpd.tearDown()
403
self._httpd.server_close()
526
404
self._http_running = False
527
# We don't need to 'self._http_thread.join()' here since the thread is
528
# a daemonic one and will be garbage collected anyway. Joining just
529
# slows us down for no added benefit.
405
self._http_thread.join()
531
407
def get_url(self):
532
408
"""See bzrlib.transport.Server.get_url."""
added
removed
bzrlib/tests/HttpServer.py
