« back to all changes in this revision
Viewing changes to bzrlib/tests/http_server.py
- browse files at revision 5396
- compare with another revision
- compare with revision 5247.3.15
- download diff
- download tarball
- view history from revision 5396
- Committer: Canonical.com Patch Queue Manager
- Date: 2010-08-30 07:47:38 UTC
- mfrom: (5394.2.1 integration2)
- Revision ID: pqm@pqm.ubuntu.com-20100830074738-ymqwum541fi8b4sr
(vila) Fix most of the leaking tests (Vincent Ladeuil)
- files added:
- bzrlib/tests/test_test_server.py
- files modified:
- NEWS
added
removed
bzrlib/tests/http_server.py
30
30
import urllib
31
31
import urlparse
32
32
33
from bzrlib import transport
33
from bzrlib import (
34
osutils,
35
tests,
36
transport,
37
)
34
38
from bzrlib.tests import test_server
35
39
from bzrlib.transport import local
36
40
71
75
self.headers.get('referer', '-'),
72
76
self.headers.get('user-agent', '-'))
73
77
78
def handle(self):
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
83
# 'makefile' objects)
84
self.connection.close()
85
74
86
def handle_one_request(self):
75
87
"""Handle a single HTTP request.
76
88
78
90
connection early to avoid polluting the test results.
79
91
"""
80
92
try:
81
SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
93
self._handle_one_request()
82
94
except socket.error, e:
83
95
# Any socket error should close the connection, but some errors are
84
96
# due to the client closing early and we don't want to pollute test
124
136
if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
125
137
self.wfile.write(content)
126
138
139
def _handle_one_request(self):
140
SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
141
127
142
_range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
128
143
_tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
129
144
248
263
# mode may cause newline translations, making the
249
264
# actual size of the content transmitted *less* than
250
265
# the content-length!
251
file = open(path, 'rb')
266
f = open(path, 'rb')
252
267
except IOError:
253
268
self.send_error(404, "File not found")
254
269
return
255
270
256
file_size = os.fstat(file.fileno())[6]
271
file_size = os.fstat(f.fileno())[6]
257
272
tail, ranges = self.parse_ranges(ranges_header_value)
258
273
# Normalize tail into ranges
259
274
if tail != 0:
280
295
# RFC2616 14.16 and 14.35 says that when a server
281
296
# encounters unsatisfiable range specifiers, it
282
297
# SHOULD return a 416.
283
file.close()
298
f.close()
284
299
# FIXME: We SHOULD send a Content-Range header too,
285
300
# but the implementation of send_error does not
286
301
# allows that. So far.
289
304
290
305
if len(ranges) == 1:
291
306
(start, end) = ranges[0]
292
self.get_single_range(file, file_size, start, end)
307
self.get_single_range(f, file_size, start, end)
293
308
else:
294
self.get_multiple_ranges(file, file_size, ranges)
295
file.close()
309
self.get_multiple_ranges(f, file_size, ranges)
310
f.close()
296
311
297
312
def translate_path(self, path):
298
313
"""Translate a /-separated PATH to the local filename syntax.
354
369
self.test_case_server = test_case_server
355
370
self._home_dir = test_case_server._home_dir
356
371
357
def stop_server(self):
358
"""Called to clean-up the server.
359
360
Since the server may be (surely is, even) in a blocking listen, we
361
shutdown its socket before closing it.
362
"""
363
# Note that is this executed as part of the implicit tear down in the
364
# main thread while the server runs in its own thread. The clean way
365
# to tear down the server is to instruct him to stop accepting
366
# connections and wait for the current connection(s) to end
367
# naturally. To end the connection naturally, the http transports
368
# should close their socket when they do not need to talk to the
369
# server anymore. This happens naturally during the garbage collection
370
# phase of the test transport objetcs (the server clients), so we
371
# don't have to worry about them. So, for the server, we must tear
372
# down here, from the main thread, when the test have ended. Note
373
# that since the server is in a blocking operation and since python
374
# use select internally, shutting down the socket is reliable and
375
# relatively clean.
376
try:
377
self.socket.shutdown(socket.SHUT_RDWR)
378
except socket.error, e:
379
# WSAENOTCONN (10057) 'Socket is not connected' is harmless on
380
# windows (occurs before the first connection attempt
381
# vila--20071230)
382
383
# 'Socket is not connected' can also occur on OSX, with a
384
# "regular" ENOTCONN (when something went wrong during test case
385
# setup leading to self.setUp() *not* being called but
386
# self.stop_server() still being called -- vila20081106
387
if not len(e.args) or e.args[0] not in (errno.ENOTCONN, 10057):
388
raise
389
# Let the server properly close the socket
390
self.server_close()
391
392
393
class TestingHTTPServer(SocketServer.TCPServer, TestingHTTPServerMixin):
372
373
class TestingHTTPServer(test_server.TestingTCPServer, TestingHTTPServerMixin):
394
374
395
375
def __init__(self, server_address, request_handler_class,
396
376
test_case_server):
377
test_server.TestingTCPServer.__init__(self, server_address,
378
request_handler_class)
397
379
TestingHTTPServerMixin.__init__(self, test_case_server)
398
SocketServer.TCPServer.__init__(self, server_address,
399
request_handler_class)
400
401
402
class TestingThreadingHTTPServer(SocketServer.ThreadingTCPServer,
380
381
382
class TestingThreadingHTTPServer(test_server.TestingThreadingTCPServer,
403
383
TestingHTTPServerMixin):
404
384
"""A threading HTTP test server for HTTP 1.1.
405
385
407
387
server, we need an independent connection for each of them. We achieve that
408
388
by spawning a new thread for each connection.
409
389
"""
410
411
390
def __init__(self, server_address, request_handler_class,
412
391
test_case_server):
392
test_server.TestingThreadingTCPServer.__init__(self, server_address,
393
request_handler_class)
413
394
TestingHTTPServerMixin.__init__(self, test_case_server)
414
SocketServer.ThreadingTCPServer.__init__(self, server_address,
415
request_handler_class)
416
# Decides how threads will act upon termination of the main
417
# process. This is prophylactic as we should not leave the threads
418
# lying around.
419
self.daemon_threads = True
420
421
def process_request_thread(self, request, client_address):
422
SocketServer.ThreadingTCPServer.process_request_thread(
423
self, request, client_address)
424
# Under some circumstances (as in bug #383920), we need to force the
425
# shutdown as python delays it until gc occur otherwise and the client
426
# may hang.
427
try:
428
# The request process has been completed, the thread is about to
429
# die, let's shutdown the socket if we can.
430
request.shutdown(socket.SHUT_RDWR)
431
except (socket.error, select.error), e:
432
if e[0] in (errno.EBADF, errno.ENOTCONN):
433
# Right, the socket is already down
434
pass
435
else:
436
raise
437
438
439
class HttpServer(transport.Server):
395
396
397
class HttpServer(test_server.TestingTCPServerInAThread):
440
398
"""A test server for http transports.
441
399
442
400
Subclasses can provide a specific request handler.
464
422
:param protocol_version: if specified, will override the protocol
465
423
version of the request handler.
466
424
"""
467
transport.Server.__init__(self)
468
self.request_handler = request_handler
425
# Depending on the protocol version, we will create the approriate
426
# server
427
if protocol_version is None:
428
# Use the request handler one
429
proto_vers = request_handler.protocol_version
430
else:
431
# Use our own, it will be used to override the request handler
432
# one too.
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)
436
if serv_cls is None:
437
raise httplib.UnknownProtocol(proto_vers)
469
438
self.host = 'localhost'
470
439
self.port = 0
471
self._httpd = None
472
self.protocol_version = protocol_version
440
super(HttpServer, self).__init__((self.host, self.port),
441
serv_cls,
442
request_handler)
443
self.protocol_version = proto_vers
473
444
# Allows tests to verify number of GET requests issued
474
445
self.GET_request_nb = 0
475
476
def create_httpd(self, serv_cls, rhandler_cls):
477
return serv_cls((self.host, self.port), self.request_handler, self)
478
479
def __repr__(self):
480
return "%s(%s:%s)" % \
481
(self.__class__.__name__, self.host, self.port)
482
483
def _get_httpd(self):
484
if self._httpd is None:
485
rhandler = self.request_handler
486
# Depending on the protocol version, we will create the approriate
487
# server
488
if self.protocol_version is None:
489
# Use the request handler one
490
proto_vers = rhandler.protocol_version
491
else:
492
# Use our own, it will be used to override the request handler
493
# one too.
494
proto_vers = self.protocol_version
495
# Create the appropriate server for the required protocol
496
serv_cls = self.http_server_class.get(proto_vers, None)
497
if serv_cls is None:
498
raise httplib.UnknownProtocol(proto_vers)
499
else:
500
self._httpd = self.create_httpd(serv_cls, rhandler)
501
self.host, self.port = self._httpd.socket.getsockname()
502
return self._httpd
503
504
def _http_start(self):
505
"""Server thread main entry point. """
506
self._http_running = False
507
try:
508
try:
509
httpd = self._get_httpd()
510
self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
511
self.host, self.port)
512
self._http_running = True
513
except:
514
# Whatever goes wrong, we save the exception for the main
515
# thread. Note that since we are running in a thread, no signal
516
# can be received, so we don't care about KeyboardInterrupt.
517
self._http_exception = sys.exc_info()
518
finally:
519
# Release the lock or the main thread will block and the whole
520
# process will hang.
521
self._http_starting.release()
522
523
# From now on, exceptions are taken care of by the
524
# SocketServer.BaseServer or the request handler.
525
while self._http_running:
526
try:
527
# Really an HTTP connection but the python framework is generic
528
# and call them requests
529
httpd.handle_request()
530
except socket.timeout:
531
pass
532
except (socket.error, select.error), e:
533
if (e[0] == errno.EBADF
534
or (sys.platform == 'win32' and e[0] == 10038)):
535
# Starting with python-2.6, handle_request may raise socket
536
# or select exceptions when the server is shut down (as we
537
# do).
538
# 10038 = WSAENOTSOCK
539
# http://msdn.microsoft.com/en-us/library/ms740668%28VS.85%29.aspx
540
pass
541
else:
542
raise
446
self._http_base_url = None
447
self.logs = []
448
449
def create_server(self):
450
return self.server_class(
451
(self.host, self.port), self.request_handler_class, self)
543
452
544
453
def _get_remote_url(self, path):
545
454
path_parts = path.split(os.path.sep)
570
479
or isinstance(backing_transport_server,
571
480
test_server.LocalURLServer)):
572
481
raise AssertionError(
573
"HTTPServer currently assumes local transport, got %s" % \
482
"HTTPServer currently assumes local transport, got %s" %
574
483
backing_transport_server)
575
484
self._home_dir = os.getcwdu()
576
485
self._local_path_parts = self._home_dir.split(os.path.sep)
577
self._http_base_url = None
578
579
# Create the server thread
580
self._http_starting = threading.Lock()
581
self._http_starting.acquire()
582
self._http_thread = threading.Thread(target=self._http_start)
583
self._http_thread.setDaemon(True)
584
self._http_exception = None
585
self._http_thread.start()
586
587
# Wait for the server thread to start (i.e release the lock)
588
self._http_starting.acquire()
589
590
if self._http_exception is not None:
591
# Something went wrong during server start
592
exc_class, exc_value, exc_tb = self._http_exception
593
raise exc_class, exc_value, exc_tb
594
self._http_starting.release()
595
486
self.logs = []
596
487
597
def stop_server(self):
598
self._httpd.stop_server()
599
self._http_running = False
600
# We don't need to 'self._http_thread.join()' here since the thread is
601
# a daemonic one and will be garbage collected anyway. Joining just
602
# slows us down for no added benefit.
488
super(HttpServer, self).start_server()
489
self._http_base_url = '%s://%s:%s/' % (
490
self._url_protocol, self.host, self.port)
603
491
604
492
def get_url(self):
605
493
"""See bzrlib.transport.Server.get_url."""
Loggerhead is a web-based interface for Breezy
Version: 2.0.1