165
130
def get_multiple_ranges(self, file, file_size, ranges):
166
131
self.send_response(206)
167
132
self.send_header('Accept-Ranges', 'bytes')
168
boundary = '%d' % random.randint(0,0x7FFFFFFF)
169
self.send_header('Content-Type',
170
'multipart/byteranges; boundary=%s' % boundary)
171
boundary_line = '--%s\r\n' % boundary
172
# Calculate the Content-Length
174
for (start, end) in ranges:
175
content_length += len(boundary_line)
176
content_length += self._header_line_length(
177
'Content-type', 'application/octet-stream')
178
content_length += self._header_line_length(
179
'Content-Range', 'bytes %d-%d/%d' % (start, end, file_size))
180
content_length += len('\r\n') # end headers
181
content_length += end - start + 1
182
content_length += len(boundary_line)
183
self.send_header('Content-length', content_length)
133
boundary = "%d" % random.randint(0,0x7FFFFFFF)
134
self.send_header("Content-Type",
135
"multipart/byteranges; boundary=%s" % boundary)
184
136
self.end_headers()
186
# Send the multipart body
187
137
for (start, end) in ranges:
188
self.wfile.write(boundary_line)
189
self.send_header('Content-type', 'application/octet-stream')
190
self.send_header('Content-Range', 'bytes %d-%d/%d'
191
% (start, end, file_size))
138
self.wfile.write("--%s\r\n" % boundary)
139
self.send_header("Content-type", 'application/octet-stream')
140
self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
192
143
self.end_headers()
193
144
self.send_range_content(file, start, end - start + 1)
195
self.wfile.write(boundary_line)
145
self.wfile.write("--%s\r\n" % boundary)
197
147
def do_GET(self):
198
148
"""Serve a GET request.
283
233
return self._translate_path(path)
285
235
def _translate_path(self, path):
286
"""Translate a /-separated PATH to the local filename syntax.
288
Note that we're translating http URLs here, not file URLs.
289
The URL root location is the server's startup directory.
290
Components that mean special things to the local file system
291
(e.g. drive or directory names) are ignored. (XXX They should
292
probably be diagnosed.)
294
Override from python standard library to stop it calling os.getcwd()
296
# abandon query parameters
297
path = urlparse.urlparse(path)[2]
298
path = posixpath.normpath(urllib.unquote(path))
299
path = path.decode('utf-8')
300
words = path.split('/')
301
words = filter(None, words)
303
for num, word in enumerate(words):
236
return SimpleHTTPRequestHandler.translate_path(self, path)
238
if sys.platform == 'win32':
239
# On win32 you cannot access non-ascii filenames without
240
# decoding them into unicode first.
241
# However, under Linux, you can access bytestream paths
242
# without any problems. If this function was always active
243
# it would probably break tests when LANG=C was set
244
def _translate_path(self, path):
245
"""Translate a /-separated PATH to the local filename syntax.
247
For bzr, all url paths are considered to be utf8 paths.
248
On Linux, you can access these paths directly over the bytestream
249
request, but on win32, you must decode them, and access them
252
# abandon query parameters
253
path = urlparse.urlparse(path)[2]
254
path = posixpath.normpath(urllib.unquote(path))
255
path = path.decode('utf-8')
256
words = path.split('/')
257
words = filter(None, words)
305
260
drive, word = os.path.splitdrive(word)
306
head, word = os.path.split(word)
307
if word in (os.curdir, os.pardir): continue
308
path = os.path.join(path, word)
312
class TestingHTTPServerMixin:
314
def __init__(self, test_case_server):
261
head, word = os.path.split(word)
262
if word in (os.curdir, os.pardir): continue
263
path = os.path.join(path, word)
267
class TestingHTTPServer(BaseHTTPServer.HTTPServer):
269
def __init__(self, server_address, RequestHandlerClass,
271
BaseHTTPServer.HTTPServer.__init__(self, server_address,
315
273
# test_case_server can be used to communicate between the
316
274
# tests and the server (or the request handler and the
317
275
# server), allowing dynamic behaviors to be defined from
318
276
# the tests cases.
319
277
self.test_case_server = test_case_server
320
self._home_dir = test_case_server._home_dir
322
def stop_server(self):
323
"""Called to clean-up the server.
325
Since the server may be (surely is, even) in a blocking listen, we
326
shutdown its socket before closing it.
328
# Note that is this executed as part of the implicit tear down in the
329
# main thread while the server runs in its own thread. The clean way
330
# to tear down the server is to instruct him to stop accepting
331
# connections and wait for the current connection(s) to end
332
# naturally. To end the connection naturally, the http transports
333
# should close their socket when they do not need to talk to the
334
# server anymore. This happens naturally during the garbage collection
335
# phase of the test transport objetcs (the server clients), so we
336
# don't have to worry about them. So, for the server, we must tear
337
# down here, from the main thread, when the test have ended. Note
338
# that since the server is in a blocking operation and since python
339
# use select internally, shutting down the socket is reliable and
342
self.socket.shutdown(socket.SHUT_RDWR)
343
except socket.error, e:
344
# WSAENOTCONN (10057) 'Socket is not connected' is harmless on
345
# windows (occurs before the first connection attempt
348
# 'Socket is not connected' can also occur on OSX, with a
349
# "regular" ENOTCONN (when something went wrong during test case
350
# setup leading to self.setUp() *not* being called but
351
# self.stop_server() still being called -- vila20081106
352
if not len(e.args) or e.args[0] not in (errno.ENOTCONN, 10057):
354
# Let the server properly close the socket
358
class TestingHTTPServer(SocketServer.TCPServer, TestingHTTPServerMixin):
360
def __init__(self, server_address, request_handler_class,
362
TestingHTTPServerMixin.__init__(self, test_case_server)
363
SocketServer.TCPServer.__init__(self, server_address,
364
request_handler_class)
367
class TestingThreadingHTTPServer(SocketServer.ThreadingTCPServer,
368
TestingHTTPServerMixin):
369
"""A threading HTTP test server for HTTP 1.1.
371
Since tests can initiate several concurrent connections to the same http
372
server, we need an independent connection for each of them. We achieve that
373
by spawning a new thread for each connection.
376
def __init__(self, server_address, request_handler_class,
378
TestingHTTPServerMixin.__init__(self, test_case_server)
379
SocketServer.ThreadingTCPServer.__init__(self, server_address,
380
request_handler_class)
381
# Decides how threads will act upon termination of the main
382
# process. This is prophylactic as we should not leave the threads
384
self.daemon_threads = True
386
def process_request_thread(self, request, client_address):
387
SocketServer.ThreadingTCPServer.process_request_thread(
388
self, request, client_address)
389
# Under some circumstances (as in bug #383920), we need to force the
390
# shutdown as python delays it until gc occur otherwise and the client
393
# The request process has been completed, the thread is about to
394
# die, let's shutdown the socket if we can.
395
request.shutdown(socket.SHUT_RDWR)
396
except (socket.error, select.error), e:
397
if e[0] in (errno.EBADF, errno.ENOTCONN):
398
# Right, the socket is already down
404
class HttpServer(transport.Server):
279
def server_close(self):
280
"""Called to clean-up the server.
282
Since the server may be in a blocking read, we shutdown the socket
285
self.socket.shutdown(socket.SHUT_RDWR)
286
BaseHTTPServer.HTTPServer.server_close(self)
289
class HttpServer(Server):
405
290
"""A test server for http transports.
407
292
Subclasses can provide a specific request handler.
410
# The real servers depending on the protocol
411
http_server_class = {'HTTP/1.0': TestingHTTPServer,
412
'HTTP/1.1': TestingThreadingHTTPServer,
415
295
# Whether or not we proxy the requests (see
416
296
# TestingHTTPRequestHandler.translate_path).
417
297
proxy_requests = False
419
299
# used to form the url that connects to this server
420
300
_url_protocol = 'http'
422
def __init__(self, request_handler=TestingHTTPRequestHandler,
423
protocol_version=None):
426
:param request_handler: a class that will be instantiated to handle an
427
http connection (one or several requests).
429
:param protocol_version: if specified, will override the protocol
430
version of the request handler.
432
transport.Server.__init__(self)
302
# Subclasses can provide a specific request handler
303
def __init__(self, request_handler=TestingHTTPRequestHandler):
304
Server.__init__(self)
433
305
self.request_handler = request_handler
434
306
self.host = 'localhost'
436
308
self._httpd = None
437
self.protocol_version = protocol_version
438
309
# Allows tests to verify number of GET requests issued
439
310
self.GET_request_nb = 0
441
def create_httpd(self, serv_cls, rhandler_cls):
442
return serv_cls((self.host, self.port), self.request_handler, self)
445
return "%s(%s:%s)" % \
446
(self.__class__.__name__, self.host, self.port)
448
312
def _get_httpd(self):
449
313
if self._httpd is None:
450
rhandler = self.request_handler
451
# Depending on the protocol version, we will create the approriate
453
if self.protocol_version is None:
454
# Use the request handler one
455
proto_vers = rhandler.protocol_version
457
# Use our own, it will be used to override the request handler
459
proto_vers = self.protocol_version
460
# Create the appropriate server for the required protocol
461
serv_cls = self.http_server_class.get(proto_vers, None)
463
raise httplib.UnknownProtocol(proto_vers)
465
self._httpd = self.create_httpd(serv_cls, rhandler)
466
self.host, self.port = self._httpd.socket.getsockname()
314
self._httpd = TestingHTTPServer((self.host, self.port),
315
self.request_handler,
317
host, self.port = self._httpd.socket.getsockname()
467
318
return self._httpd
469
320
def _http_start(self):
470
"""Server thread main entry point. """
471
self._http_running = False
474
httpd = self._get_httpd()
475
self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
476
self.host, self.port)
477
self._http_running = True
479
# Whatever goes wrong, we save the exception for the main
480
# thread. Note that since we are running in a thread, no signal
481
# can be received, so we don't care about KeyboardInterrupt.
482
self._http_exception = sys.exc_info()
484
# Release the lock or the main thread will block and the whole
486
self._http_starting.release()
321
httpd = self._get_httpd()
322
self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
325
self._http_starting.release()
488
# From now on, exceptions are taken care of by the
489
# SocketServer.BaseServer or the request handler.
490
327
while self._http_running:
492
# Really an HTTP connection but the python framework is generic
493
# and call them requests
494
329
httpd.handle_request()
495
330
except socket.timeout:
497
except (socket.error, select.error), e:
498
if (e[0] == errno.EBADF
499
or (sys.platform == 'win32' and e[0] == 10038)):
500
# Starting with python-2.6, handle_request may raise socket
501
# or select exceptions when the server is shut down (as we
503
# 10038 = WSAENOTSOCK
504
# http://msdn.microsoft.com/en-us/library/ms740668%28VS.85%29.aspx
509
333
def _get_remote_url(self, path):
510
334
path_parts = path.split(os.path.sep)
522
346
"""Capture Server log output."""
523
347
self.logs.append(format % args)
525
def start_server(self, backing_transport_server=None):
526
"""See bzrlib.transport.Server.start_server.
349
def setUp(self, backing_transport_server=None):
350
"""See bzrlib.transport.Server.setUp.
528
352
:param backing_transport_server: The transport that requests over this
529
353
protocol should be forwarded to. Note that this is currently not
530
354
supported for HTTP.
532
356
# XXX: TODO: make the server back onto vfs_server rather than local
534
if not (backing_transport_server is None
535
or isinstance(backing_transport_server,
536
test_server.LocalURLServer)):
537
raise AssertionError(
538
"HTTPServer currently assumes local transport, got %s" % \
539
backing_transport_server)
358
assert backing_transport_server is None or \
359
isinstance(backing_transport_server, LocalURLServer), \
360
"HTTPServer currently assumes local transport, got %s" % \
361
backing_transport_server
540
362
self._home_dir = os.getcwdu()
541
363
self._local_path_parts = self._home_dir.split(os.path.sep)
364
self._http_starting = threading.Lock()
365
self._http_starting.acquire()
366
self._http_running = True
542
367
self._http_base_url = None
544
# Create the server thread
545
self._http_starting = threading.Lock()
546
self._http_starting.acquire()
547
368
self._http_thread = threading.Thread(target=self._http_start)
548
369
self._http_thread.setDaemon(True)
549
self._http_exception = None
550
370
self._http_thread.start()
552
371
# Wait for the server thread to start (i.e release the lock)
553
372
self._http_starting.acquire()
555
if self._http_exception is not None:
556
# Something went wrong during server start
557
exc_class, exc_value, exc_tb = self._http_exception
558
raise exc_class, exc_value, exc_tb
559
373
self._http_starting.release()
562
def stop_server(self):
563
self._httpd.stop_server()
377
"""See bzrlib.transport.Server.tearDown."""
378
self._httpd.server_close()
564
379
self._http_running = False
565
# We don't need to 'self._http_thread.join()' here since the thread is
566
# a daemonic one and will be garbage collected anyway. Joining just
567
# slows us down for no added benefit.
380
self._http_thread.join()
569
382
def get_url(self):
570
383
"""See bzrlib.transport.Server.get_url."""
added
removed
bzrlib/tests/HttpServer.py
