40
39
return 'path %s is not in %s' % self.args
43
class TestingHTTPRequestHandler(SimpleHTTPRequestHandler):
42
class TestingHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
43
"""Handles one request.
45
A TestingHTTPRequestHandler is instantiated for every request received by
46
the associated server. Note that 'request' here is inherited from the base
47
TCPServer class, for the HTTP server it is really a connection which itself
48
will handle one or several HTTP requests.
50
# Default protocol version
51
protocol_version = 'HTTP/1.1'
53
# The Message-like class used to parse the request headers
54
MessageClass = httplib.HTTPMessage
57
SimpleHTTPServer.SimpleHTTPRequestHandler.setup(self)
58
self._cwd = self.server._home_dir
59
tcs = self.server.test_case_server
60
if tcs.protocol_version is not None:
61
# If the test server forced a protocol version, use it
62
self.protocol_version = tcs.protocol_version
45
64
def log_message(self, format, *args):
46
self.server.test_case.log('webserver - %s - - [%s] %s "%s" "%s"',
47
self.address_string(),
48
self.log_date_time_string(),
50
self.headers.get('referer', '-'),
51
self.headers.get('user-agent', '-'))
65
tcs = self.server.test_case_server
66
tcs.log('webserver - %s - - [%s] %s "%s" "%s"',
67
self.address_string(),
68
self.log_date_time_string(),
70
self.headers.get('referer', '-'),
71
self.headers.get('user-agent', '-'))
53
73
def handle_one_request(self):
54
74
"""Handle a single HTTP request.
56
You normally don't need to override this method; see the class
57
__doc__ string for information on how to handle specific HTTP
58
commands such as GET and POST.
76
We catch all socket errors occurring when the client close the
77
connection early to avoid polluting the test results.
61
for i in xrange(1,11): # Don't try more than 10 times
63
self.raw_requestline = self.rfile.readline()
64
except socket.error, e:
65
if e.args[0] in (errno.EAGAIN, errno.EWOULDBLOCK):
66
# omitted for now because some tests look at the log of
67
# the server and expect to see no errors. see recent
68
# email thread. -- mbp 20051021.
69
## self.log_message('EAGAIN (%d) while reading from raw_requestline' % i)
80
SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
81
except socket.error, e:
82
# Any socket error should close the connection, but some errors are
83
# due to the client closing early and we don't want to pollute test
84
# results, so we raise only the others.
85
self.close_connection = 1
87
or e.args[0] not in (errno.EPIPE, errno.ECONNRESET,
88
errno.ECONNABORTED, errno.EBADF)):
75
if not self.raw_requestline:
76
self.close_connection = 1
78
if not self.parse_request(): # An error code has been sent, just exit
80
mname = 'do_' + self.command
81
if getattr(self, mname, None) is None:
82
self.send_error(501, "Unsupported method (%r)" % self.command)
84
method = getattr(self, mname)
87
91
_range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
88
92
_tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
140
164
def get_multiple_ranges(self, file, file_size, ranges):
141
165
self.send_response(206)
142
166
self.send_header('Accept-Ranges', 'bytes')
143
boundary = "%d" % random.randint(0,0x7FFFFFFF)
144
self.send_header("Content-Type",
145
"multipart/byteranges; boundary=%s" % boundary)
167
boundary = '%d' % random.randint(0,0x7FFFFFFF)
168
self.send_header('Content-Type',
169
'multipart/byteranges; boundary=%s' % boundary)
170
boundary_line = '--%s\r\n' % boundary
171
# Calculate the Content-Length
173
for (start, end) in ranges:
174
content_length += len(boundary_line)
175
content_length += self._header_line_length(
176
'Content-type', 'application/octet-stream')
177
content_length += self._header_line_length(
178
'Content-Range', 'bytes %d-%d/%d' % (start, end, file_size))
179
content_length += len('\r\n') # end headers
180
content_length += end - start + 1
181
content_length += len(boundary_line)
182
self.send_header('Content-length', content_length)
146
183
self.end_headers()
185
# Send the multipart body
147
186
for (start, end) in ranges:
148
self.wfile.write("--%s\r\n" % boundary)
149
self.send_header("Content-type", 'application/octet-stream')
150
self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
187
self.wfile.write(boundary_line)
188
self.send_header('Content-type', 'application/octet-stream')
189
self.send_header('Content-Range', 'bytes %d-%d/%d'
190
% (start, end, file_size))
153
191
self.end_headers()
154
192
self.send_range_content(file, start, end - start + 1)
155
self.wfile.write("--%s\r\n" % boundary)
194
self.wfile.write(boundary_line)
158
196
def do_GET(self):
159
197
"""Serve a GET request.
161
199
Handles the Range header.
202
self.server.test_case_server.GET_request_nb += 1
164
204
path = self.translate_path(self.path)
165
205
ranges_header_value = self.headers.get('Range')
166
206
if ranges_header_value is None or os.path.isdir(path):
167
207
# Let the mother class handle most cases
168
return SimpleHTTPRequestHandler.do_GET(self)
208
return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
171
211
# Always read in binary mode. Opening files in text
218
258
self.get_multiple_ranges(file, file_size, ranges)
221
if sys.platform == 'win32':
222
# On win32 you cannot access non-ascii filenames without
223
# decoding them into unicode first.
224
# However, under Linux, you can access bytestream paths
225
# without any problems. If this function was always active
226
# it would probably break tests when LANG=C was set
227
def translate_path(self, path):
228
"""Translate a /-separated PATH to the local filename syntax.
230
For bzr, all url paths are considered to be utf8 paths.
231
On Linux, you can access these paths directly over the bytestream
232
request, but on win32, you must decode them, and access them
235
# abandon query parameters
261
def translate_path(self, path):
262
"""Translate a /-separated PATH to the local filename syntax.
264
If the server requires it, proxy the path before the usual translation
266
if self.server.test_case_server.proxy_requests:
267
# We need to act as a proxy and accept absolute urls,
268
# which SimpleHTTPRequestHandler (parent) is not
269
# ready for. So we just drop the protocol://host:port
270
# part in front of the request-url (because we know
271
# we would not forward the request to *another*
274
# So we do what SimpleHTTPRequestHandler.translate_path
275
# do beginning with python 2.4.3: abandon query
276
# parameters, scheme, host port, etc (which ensure we
277
# provide the right behaviour on all python versions).
236
278
path = urlparse.urlparse(path)[2]
237
path = posixpath.normpath(urllib.unquote(path))
238
path = path.decode('utf-8')
239
words = path.split('/')
240
words = filter(None, words)
279
# And now, we can apply *our* trick to proxy files
282
return self._translate_path(path)
284
def _translate_path(self, path):
285
"""Translate a /-separated PATH to the local filename syntax.
287
Note that we're translating http URLs here, not file URLs.
288
The URL root location is the server's startup directory.
289
Components that mean special things to the local file system
290
(e.g. drive or directory names) are ignored. (XXX They should
291
probably be diagnosed.)
293
Override from python standard library to stop it calling os.getcwd()
295
# abandon query parameters
296
path = urlparse.urlparse(path)[2]
297
path = posixpath.normpath(urllib.unquote(path))
298
path = path.decode('utf-8')
299
words = path.split('/')
300
words = filter(None, words)
302
for num, word in enumerate(words):
243
304
drive, word = os.path.splitdrive(word)
244
head, word = os.path.split(word)
245
if word in (os.curdir, os.pardir): continue
246
path = os.path.join(path, word)
250
class TestingHTTPServer(BaseHTTPServer.HTTPServer):
251
def __init__(self, server_address, RequestHandlerClass, test_case):
252
BaseHTTPServer.HTTPServer.__init__(self, server_address,
254
self.test_case = test_case
257
class HttpServer(Server):
305
head, word = os.path.split(word)
306
if word in (os.curdir, os.pardir): continue
307
path = os.path.join(path, word)
311
class TestingHTTPServerMixin:
313
def __init__(self, test_case_server):
314
# test_case_server can be used to communicate between the
315
# tests and the server (or the request handler and the
316
# server), allowing dynamic behaviors to be defined from
318
self.test_case_server = test_case_server
319
self._home_dir = test_case_server._home_dir
322
"""Called to clean-up the server.
324
Since the server may be (surely is, even) in a blocking listen, we
325
shutdown its socket before closing it.
327
# Note that is this executed as part of the implicit tear down in the
328
# main thread while the server runs in its own thread. The clean way
329
# to tear down the server is to instruct him to stop accepting
330
# connections and wait for the current connection(s) to end
331
# naturally. To end the connection naturally, the http transports
332
# should close their socket when they do not need to talk to the
333
# server anymore. This happens naturally during the garbage collection
334
# phase of the test transport objetcs (the server clients), so we
335
# don't have to worry about them. So, for the server, we must tear
336
# down here, from the main thread, when the test have ended. Note
337
# that since the server is in a blocking operation and since python
338
# use select internally, shutting down the socket is reliable and
341
self.socket.shutdown(socket.SHUT_RDWR)
342
except socket.error, e:
343
# WSAENOTCONN (10057) 'Socket is not connected' is harmless on
344
# windows (occurs before the first connection attempt
347
# 'Socket is not connected' can also occur on OSX, with a
348
# "regular" ENOTCONN (when something went wrong during test case
349
# setup leading to self.setUp() *not* being called but
350
# self.tearDown() still being called -- vila20081106
351
if not len(e.args) or e.args[0] not in (errno.ENOTCONN, 10057):
353
# Let the server properly close the socket
357
class TestingHTTPServer(SocketServer.TCPServer, TestingHTTPServerMixin):
359
def __init__(self, server_address, request_handler_class,
361
TestingHTTPServerMixin.__init__(self, test_case_server)
362
SocketServer.TCPServer.__init__(self, server_address,
363
request_handler_class)
366
class TestingThreadingHTTPServer(SocketServer.ThreadingTCPServer,
367
TestingHTTPServerMixin):
368
"""A threading HTTP test server for HTTP 1.1.
370
Since tests can initiate several concurrent connections to the same http
371
server, we need an independent connection for each of them. We achieve that
372
by spawning a new thread for each connection.
375
def __init__(self, server_address, request_handler_class,
377
TestingHTTPServerMixin.__init__(self, test_case_server)
378
SocketServer.ThreadingTCPServer.__init__(self, server_address,
379
request_handler_class)
380
# Decides how threads will act upon termination of the main
381
# process. This is prophylactic as we should not leave the threads
383
self.daemon_threads = True
386
class HttpServer(transport.Server):
258
387
"""A test server for http transports.
260
389
Subclasses can provide a specific request handler.
392
# The real servers depending on the protocol
393
http_server_class = {'HTTP/1.0': TestingHTTPServer,
394
'HTTP/1.1': TestingThreadingHTTPServer,
397
# Whether or not we proxy the requests (see
398
# TestingHTTPRequestHandler.translate_path).
399
proxy_requests = False
263
401
# used to form the url that connects to this server
264
402
_url_protocol = 'http'
266
# Subclasses can provide a specific request handler
267
def __init__(self, request_handler=TestingHTTPRequestHandler):
268
Server.__init__(self)
404
def __init__(self, request_handler=TestingHTTPRequestHandler,
405
protocol_version=None):
408
:param request_handler: a class that will be instantiated to handle an
409
http connection (one or several requests).
411
:param protocol_version: if specified, will override the protocol
412
version of the request handler.
414
transport.Server.__init__(self)
269
415
self.request_handler = request_handler
416
self.host = 'localhost'
419
self.protocol_version = protocol_version
420
# Allows tests to verify number of GET requests issued
421
self.GET_request_nb = 0
423
def create_httpd(self, serv_cls, rhandler_cls):
424
return serv_cls((self.host, self.port), self.request_handler, self)
427
return "%s(%s:%s)" % \
428
(self.__class__.__name__, self.host, self.port)
271
430
def _get_httpd(self):
272
return TestingHTTPServer(('localhost', 0),
273
self.request_handler,
431
if self._httpd is None:
432
rhandler = self.request_handler
433
# Depending on the protocol version, we will create the approriate
435
if self.protocol_version is None:
436
# Use the request handler one
437
proto_vers = rhandler.protocol_version
439
# Use our own, it will be used to override the request handler
441
proto_vers = self.protocol_version
442
# Create the appropriate server for the required protocol
443
serv_cls = self.http_server_class.get(proto_vers, None)
445
raise httplib.UnknownProtocol(proto_vers)
447
self._httpd = self.create_httpd(serv_cls, rhandler)
448
host, self.port = self._httpd.socket.getsockname()
276
451
def _http_start(self):
278
httpd = self._get_httpd()
279
host, self.port = httpd.socket.getsockname()
280
self._http_base_url = '%s://localhost:%s/' % (self._url_protocol,
282
self._http_starting.release()
283
httpd.socket.settimeout(0.1)
452
"""Server thread main entry point. """
453
self._http_running = False
456
httpd = self._get_httpd()
457
self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
458
self.host, self.port)
459
self._http_running = True
461
# Whatever goes wrong, we save the exception for the main
462
# thread. Note that since we are running in a thread, no signal
463
# can be received, so we don't care about KeyboardInterrupt.
464
self._http_exception = sys.exc_info()
466
# Release the lock or the main thread will block and the whole
468
self._http_starting.release()
470
# From now on, exceptions are taken care of by the
471
# SocketServer.BaseServer or the request handler.
285
472
while self._http_running:
474
# Really an HTTP connection but the python framework is generic
475
# and call them requests
287
476
httpd.handle_request()
288
477
except socket.timeout:
479
except (socket.error, select.error), e:
480
if e[0] == errno.EBADF:
481
# Starting with python-2.6, handle_request may raise socket
482
# or select exceptions when the server is shut down (as we
291
488
def _get_remote_url(self, path):
292
489
path_parts = path.split(os.path.sep)
304
501
"""Capture Server log output."""
305
502
self.logs.append(format % args)
308
"""See bzrlib.transport.Server.setUp."""
504
def setUp(self, backing_transport_server=None):
505
"""See bzrlib.transport.Server.setUp.
507
:param backing_transport_server: The transport that requests over this
508
protocol should be forwarded to. Note that this is currently not
511
# XXX: TODO: make the server back onto vfs_server rather than local
513
if not (backing_transport_server is None or \
514
isinstance(backing_transport_server, local.LocalURLServer)):
515
raise AssertionError(
516
"HTTPServer currently assumes local transport, got %s" % \
517
backing_transport_server)
309
518
self._home_dir = os.getcwdu()
310
519
self._local_path_parts = self._home_dir.split(os.path.sep)
520
self._http_base_url = None
522
# Create the server thread
311
523
self._http_starting = threading.Lock()
312
524
self._http_starting.acquire()
313
self._http_running = True
314
self._http_base_url = None
315
525
self._http_thread = threading.Thread(target=self._http_start)
316
526
self._http_thread.setDaemon(True)
527
self._http_exception = None
317
528
self._http_thread.start()
318
530
# Wait for the server thread to start (i.e release the lock)
319
531
self._http_starting.acquire()
533
if self._http_exception is not None:
534
# Something went wrong during server start
535
exc_class, exc_value, exc_tb = self._http_exception
536
raise exc_class, exc_value, exc_tb
320
537
self._http_starting.release()
323
540
def tearDown(self):
324
541
"""See bzrlib.transport.Server.tearDown."""
542
self._httpd.tearDown()
325
543
self._http_running = False
326
self._http_thread.join()
544
# We don't need to 'self._http_thread.join()' here since the thread is
545
# a daemonic one and will be garbage collected anyway. Joining just
546
# slows us down for no added benefit.
328
548
def get_url(self):
329
549
"""See bzrlib.transport.Server.get_url."""
added
removed
bzrlib/tests/http_server.py
