90
88
errno.ECONNABORTED, errno.EBADF)):
93
error_content_type = 'text/plain'
94
error_message_format = '''\
99
def send_error(self, code, message=None):
100
"""Send and log an error reply.
102
We redefine the python-provided version to be able to set a
103
``Content-Length`` header as some http/1.1 clients complain otherwise
106
:param code: The HTTP error code.
108
:param message: The explanation of the error code, Defaults to a short
114
message = self.responses[code][0]
117
self.log_error("code %d, message %s", code, message)
118
content = (self.error_message_format %
119
{'code': code, 'message': message})
120
self.send_response(code, message)
121
self.send_header("Content-Type", self.error_content_type)
122
self.send_header("Content-Length", "%d" % len(content))
123
self.send_header('Connection', 'close')
125
if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
126
self.wfile.write(content)
128
def _handle_one_request(self):
129
SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
131
_range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)?$')
91
_range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
132
92
_tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
134
def _parse_ranges(self, ranges_header, file_size):
135
"""Parse the range header value and returns ranges.
137
RFC2616 14.35 says that syntactically invalid range specifiers MUST be
138
ignored. In that case, we return None instead of a range list.
140
:param ranges_header: The 'Range' header value.
142
:param file_size: The size of the requested file.
144
:return: A list of (start, end) tuples or None if some invalid range
145
specifier is encountered.
94
def parse_ranges(self, ranges_header):
95
"""Parse the range header value and returns ranges and tail.
97
RFC2616 14.35 says that syntactically invalid range
98
specifiers MUST be ignored. In that case, we return 0 for
99
tail and [] for ranges.
147
103
if not ranges_header.startswith('bytes='):
148
104
# Syntactically invalid header
153
107
ranges_header = ranges_header[len('bytes='):]
154
108
for range_str in ranges_header.split(','):
109
# FIXME: RFC2616 says end is optional and default to file_size
155
110
range_match = self._range_regexp.match(range_str)
156
111
if range_match is not None:
157
112
start = int(range_match.group('start'))
158
end_match = range_match.group('end')
159
if end_match is None:
160
# RFC2616 says end is optional and default to file_size
113
end = int(range_match.group('end'))
165
115
# Syntactically invalid range
167
117
ranges.append((start, end))
169
119
tail_match = self._tail_regexp.match(range_str)
171
121
tail = int(tail_match.group('tail'))
173
123
# Syntactically invalid range
176
# Normalize tail into ranges
177
ranges.append((max(0, file_size - tail), file_size))
180
for start, end in ranges:
181
if start >= file_size:
182
# RFC2616 14.35, ranges are invalid if start >= file_size
184
# RFC2616 14.35, end values should be truncated
185
# to file_size -1 if they exceed it
186
end = min(end, file_size - 1)
187
checked_ranges.append((start, end))
188
return checked_ranges
190
127
def _header_line_length(self, keyword, value):
191
128
header_line = '%s: %s\r\n' % (keyword, value)
275
212
# mode may cause newline translations, making the
276
213
# actual size of the content transmitted *less* than
277
214
# the content-length!
215
file = open(path, 'rb')
280
217
self.send_error(404, "File not found")
283
file_size = os.fstat(f.fileno())[6]
284
ranges = self._parse_ranges(ranges_header_value, file_size)
220
file_size = os.fstat(file.fileno())[6]
221
tail, ranges = self.parse_ranges(ranges_header_value)
222
# Normalize tail into ranges
224
ranges.append((file_size - tail, file_size))
226
self._satisfiable_ranges = True
228
self._satisfiable_ranges = False
230
def check_range(range_specifier):
231
start, end = range_specifier
232
# RFC2616 14.35, ranges are invalid if start >= file_size
233
if start >= file_size:
234
self._satisfiable_ranges = False # Side-effect !
236
# RFC2616 14.35, end values should be truncated
237
# to file_size -1 if they exceed it
238
end = min(end, file_size - 1)
241
ranges = map(check_range, ranges)
243
if not self._satisfiable_ranges:
286
244
# RFC2616 14.16 and 14.35 says that when a server
287
245
# encounters unsatisfiable range specifiers, it
288
246
# SHOULD return a 416.
290
248
# FIXME: We SHOULD send a Content-Range header too,
291
249
# but the implementation of send_error does not
292
250
# allows that. So far.
296
254
if len(ranges) == 1:
297
255
(start, end) = ranges[0]
298
self.get_single_range(f, file_size, start, end)
256
self.get_single_range(file, file_size, start, end)
300
self.get_multiple_ranges(f, file_size, ranges)
258
self.get_multiple_ranges(file, file_size, ranges)
303
261
def translate_path(self, path):
304
262
"""Translate a /-separated PATH to the local filename syntax.
360
318
self.test_case_server = test_case_server
361
319
self._home_dir = test_case_server._home_dir
364
class TestingHTTPServer(test_server.TestingTCPServer, TestingHTTPServerMixin):
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):
366
359
def __init__(self, server_address, request_handler_class,
367
360
test_case_server):
368
test_server.TestingTCPServer.__init__(self, server_address,
369
request_handler_class)
370
361
TestingHTTPServerMixin.__init__(self, test_case_server)
373
class TestingThreadingHTTPServer(test_server.TestingThreadingTCPServer,
362
SocketServer.TCPServer.__init__(self, server_address,
363
request_handler_class)
366
class TestingThreadingHTTPServer(SocketServer.ThreadingTCPServer,
374
367
TestingHTTPServerMixin):
375
368
"""A threading HTTP test server for HTTP 1.1.
378
371
server, we need an independent connection for each of them. We achieve that
379
372
by spawning a new thread for each connection.
381
375
def __init__(self, server_address, request_handler_class,
382
376
test_case_server):
383
test_server.TestingThreadingTCPServer.__init__(self, server_address,
384
request_handler_class)
385
377
TestingHTTPServerMixin.__init__(self, test_case_server)
388
class HttpServer(test_server.TestingTCPServerInAThread):
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
385
def process_request_thread(self, request, client_address):
386
SocketServer.ThreadingTCPServer.process_request_thread(
387
self, request, client_address)
388
# Under some circumstances (as in bug #383920), we need to force the
389
# shutdown as python delays it until gc occur otherwise and the client
392
# The request process has been completed, the thread is about to
393
# die, let's shutdown the socket if we can.
394
request.shutdown(socket.SHUT_RDWR)
395
except (socket.error, select.error), e:
396
if e[0] in (errno.EBADF, errno.ENOTCONN):
397
# Right, the socket is already down
403
class HttpServer(transport.Server):
389
404
"""A test server for http transports.
391
406
Subclasses can provide a specific request handler.
413
428
:param protocol_version: if specified, will override the protocol
414
429
version of the request handler.
416
# Depending on the protocol version, we will create the approriate
418
if protocol_version is None:
419
# Use the request handler one
420
proto_vers = request_handler.protocol_version
422
# Use our own, it will be used to override the request handler
424
proto_vers = protocol_version
425
# Get the appropriate server class for the required protocol
426
serv_cls = self.http_server_class.get(proto_vers, None)
428
raise httplib.UnknownProtocol(proto_vers)
431
transport.Server.__init__(self)
432
self.request_handler = request_handler
429
433
self.host = 'localhost'
431
super(HttpServer, self).__init__((self.host, self.port),
434
self.protocol_version = proto_vers
436
self.protocol_version = protocol_version
435
437
# Allows tests to verify number of GET requests issued
436
438
self.GET_request_nb = 0
437
self._http_base_url = None
440
def create_server(self):
441
return self.server_class(
442
(self.host, self.port), self.request_handler_class, self)
440
def create_httpd(self, serv_cls, rhandler_cls):
441
return serv_cls((self.host, self.port), self.request_handler, self)
444
return "%s(%s:%s)" % \
445
(self.__class__.__name__, self.host, self.port)
447
def _get_httpd(self):
448
if self._httpd is None:
449
rhandler = self.request_handler
450
# Depending on the protocol version, we will create the approriate
452
if self.protocol_version is None:
453
# Use the request handler one
454
proto_vers = rhandler.protocol_version
456
# Use our own, it will be used to override the request handler
458
proto_vers = self.protocol_version
459
# Create the appropriate server for the required protocol
460
serv_cls = self.http_server_class.get(proto_vers, None)
462
raise httplib.UnknownProtocol(proto_vers)
464
self._httpd = self.create_httpd(serv_cls, rhandler)
465
host, self.port = self._httpd.socket.getsockname()
468
def _http_start(self):
469
"""Server thread main entry point. """
470
self._http_running = False
473
httpd = self._get_httpd()
474
self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
475
self.host, self.port)
476
self._http_running = True
478
# Whatever goes wrong, we save the exception for the main
479
# thread. Note that since we are running in a thread, no signal
480
# can be received, so we don't care about KeyboardInterrupt.
481
self._http_exception = sys.exc_info()
483
# Release the lock or the main thread will block and the whole
485
self._http_starting.release()
487
# From now on, exceptions are taken care of by the
488
# SocketServer.BaseServer or the request handler.
489
while self._http_running:
491
# Really an HTTP connection but the python framework is generic
492
# and call them requests
493
httpd.handle_request()
494
except socket.timeout:
496
except (socket.error, select.error), e:
497
if e[0] == errno.EBADF:
498
# Starting with python-2.6, handle_request may raise socket
499
# or select exceptions when the server is shut down (as we
444
505
def _get_remote_url(self, path):
445
506
path_parts = path.split(os.path.sep)
467
528
# XXX: TODO: make the server back onto vfs_server rather than local
469
if not (backing_transport_server is None
470
or isinstance(backing_transport_server,
471
test_server.LocalURLServer)):
530
if not (backing_transport_server is None or \
531
isinstance(backing_transport_server, local.LocalURLServer)):
472
532
raise AssertionError(
473
"HTTPServer currently assumes local transport, got %s" %
533
"HTTPServer currently assumes local transport, got %s" % \
474
534
backing_transport_server)
475
535
self._home_dir = os.getcwdu()
476
536
self._local_path_parts = self._home_dir.split(os.path.sep)
537
self._http_base_url = None
539
# Create the server thread
540
self._http_starting = threading.Lock()
541
self._http_starting.acquire()
542
self._http_thread = threading.Thread(target=self._http_start)
543
self._http_thread.setDaemon(True)
544
self._http_exception = None
545
self._http_thread.start()
547
# Wait for the server thread to start (i.e release the lock)
548
self._http_starting.acquire()
550
if self._http_exception is not None:
551
# Something went wrong during server start
552
exc_class, exc_value, exc_tb = self._http_exception
553
raise exc_class, exc_value, exc_tb
554
self._http_starting.release()
479
super(HttpServer, self).start_server()
480
self._http_base_url = '%s://%s:%s/' % (
481
self._url_protocol, self.host, self.port)
558
"""See bzrlib.transport.Server.tearDown."""
559
self._httpd.tearDown()
560
self._http_running = False
561
# We don't need to 'self._http_thread.join()' here since the thread is
562
# a daemonic one and will be garbage collected anyway. Joining just
563
# slows us down for no added benefit.
483
565
def get_url(self):
484
566
"""See bzrlib.transport.Server.get_url."""
added
removed
bzrlib/tests/http_server.py
