13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
64
72
self.headers.get('referer', '-'),
65
73
self.headers.get('user-agent', '-'))
68
SimpleHTTPServer.SimpleHTTPRequestHandler.handle(self)
69
# Some client (pycurl, I'm looking at you) are more picky than others
70
# and require that the socket itself is closed
71
# (SocketServer.StreamRequestHandler only close the two associated
73
self.connection.close()
75
75
def handle_one_request(self):
76
76
"""Handle a single HTTP request.
90
90
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+)?$')
93
_range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
132
94
_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.
96
def parse_ranges(self, ranges_header):
97
"""Parse the range header value and returns ranges and tail.
99
RFC2616 14.35 says that syntactically invalid range
100
specifiers MUST be ignored. In that case, we return 0 for
101
tail and [] for ranges.
147
105
if not ranges_header.startswith('bytes='):
148
106
# Syntactically invalid header
153
109
ranges_header = ranges_header[len('bytes='):]
154
110
for range_str in ranges_header.split(','):
111
# FIXME: RFC2616 says end is optional and default to file_size
155
112
range_match = self._range_regexp.match(range_str)
156
113
if range_match is not None:
157
114
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
115
end = int(range_match.group('end'))
165
117
# Syntactically invalid range
167
119
ranges.append((start, end))
169
121
tail_match = self._tail_regexp.match(range_str)
171
123
tail = int(tail_match.group('tail'))
173
125
# 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
129
def _header_line_length(self, keyword, value):
191
130
header_line = '%s: %s\r\n' % (keyword, value)
240
179
content_length += self._header_line_length(
241
180
'Content-Range', 'bytes %d-%d/%d' % (start, end, file_size))
242
181
content_length += len('\r\n') # end headers
243
content_length += end - start + 1
182
content_length += end - start # + 1
244
183
content_length += len(boundary_line)
245
184
self.send_header('Content-length', content_length)
246
185
self.end_headers()
275
214
# mode may cause newline translations, making the
276
215
# actual size of the content transmitted *less* than
277
216
# the content-length!
217
file = open(path, 'rb')
280
219
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)
222
file_size = os.fstat(file.fileno())[6]
223
tail, ranges = self.parse_ranges(ranges_header_value)
224
# Normalize tail into ranges
226
ranges.append((file_size - tail, file_size))
228
self._satisfiable_ranges = True
230
self._satisfiable_ranges = False
232
def check_range(range_specifier):
233
start, end = range_specifier
234
# RFC2616 14.35, ranges are invalid if start >= file_size
235
if start >= file_size:
236
self._satisfiable_ranges = False # Side-effect !
238
# RFC2616 14.35, end values should be truncated
239
# to file_size -1 if they exceed it
240
end = min(end, file_size - 1)
243
ranges = map(check_range, ranges)
245
if not self._satisfiable_ranges:
286
246
# RFC2616 14.16 and 14.35 says that when a server
287
247
# encounters unsatisfiable range specifiers, it
288
248
# SHOULD return a 416.
290
250
# FIXME: We SHOULD send a Content-Range header too,
291
251
# but the implementation of send_error does not
292
252
# allows that. So far.
296
256
if len(ranges) == 1:
297
257
(start, end) = ranges[0]
298
self.get_single_range(f, file_size, start, end)
258
self.get_single_range(file, file_size, start, end)
300
self.get_multiple_ranges(f, file_size, ranges)
260
self.get_multiple_ranges(file, file_size, ranges)
303
263
def translate_path(self, path):
304
264
"""Translate a /-separated PATH to the local filename syntax.
324
284
return self._translate_path(path)
326
286
def _translate_path(self, path):
327
"""Translate a /-separated PATH to the local filename syntax.
329
Note that we're translating http URLs here, not file URLs.
330
The URL root location is the server's startup directory.
331
Components that mean special things to the local file system
332
(e.g. drive or directory names) are ignored. (XXX They should
333
probably be diagnosed.)
335
Override from python standard library to stop it calling os.getcwd()
337
# abandon query parameters
338
path = urlparse.urlparse(path)[2]
339
path = posixpath.normpath(urllib.unquote(path))
340
path = path.decode('utf-8')
341
words = path.split('/')
342
words = filter(None, words)
344
for num, word in enumerate(words):
287
return SimpleHTTPServer.SimpleHTTPRequestHandler.translate_path(
290
if sys.platform == 'win32':
291
# On win32 you cannot access non-ascii filenames without
292
# decoding them into unicode first.
293
# However, under Linux, you can access bytestream paths
294
# without any problems. If this function was always active
295
# it would probably break tests when LANG=C was set
296
def _translate_path(self, path):
297
"""Translate a /-separated PATH to the local filename syntax.
299
For bzr, all url paths are considered to be utf8 paths.
300
On Linux, you can access these paths directly over the bytestream
301
request, but on win32, you must decode them, and access them
304
# abandon query parameters
305
path = urlparse.urlparse(path)[2]
306
path = posixpath.normpath(urllib.unquote(path))
307
path = path.decode('utf-8')
308
words = path.split('/')
309
words = filter(None, words)
346
312
drive, word = os.path.splitdrive(word)
347
head, word = os.path.split(word)
348
if word in (os.curdir, os.pardir): continue
349
path = os.path.join(path, word)
313
head, word = os.path.split(word)
314
if word in (os.curdir, os.pardir): continue
315
path = os.path.join(path, word)
353
319
class TestingHTTPServerMixin:
358
324
# server), allowing dynamic behaviors to be defined from
359
325
# the tests cases.
360
326
self.test_case_server = test_case_server
361
self._home_dir = test_case_server._home_dir
364
class TestingHTTPServer(test_server.TestingTCPServer, TestingHTTPServerMixin):
329
"""Called to clean-up the server.
331
Since the server may be (surely is, even) in a blocking listen, we
332
shutdown its socket before closing it.
334
# Note that is this executed as part of the implicit tear down in the
335
# main thread while the server runs in its own thread. The clean way
336
# to tear down the server is to instruct him to stop accepting
337
# connections and wait for the current connection(s) to end
338
# naturally. To end the connection naturally, the http transports
339
# should close their socket when they do not need to talk to the
340
# server anymore. This happens naturally during the garbage collection
341
# phase of the test transport objetcs (the server clients), so we
342
# don't have to worry about them. So, for the server, we must tear
343
# down here, from the main thread, when the test have ended. Note
344
# that since the server is in a blocking operation and since python
345
# use select internally, shutting down the socket is reliable and
348
self.socket.shutdown(socket.SHUT_RDWR)
349
except socket.error, e:
350
# WSAENOTCONN (10057) 'Socket is not connected' is harmless on
351
# windows (occurs before the first connection attempt
353
if not len(e.args) or e.args[0] != 10057:
355
# Let the server properly close the socket
358
class TestingHTTPServer(SocketServer.TCPServer, TestingHTTPServerMixin):
366
360
def __init__(self, server_address, request_handler_class,
367
361
test_case_server):
368
test_server.TestingTCPServer.__init__(self, server_address,
369
request_handler_class)
370
362
TestingHTTPServerMixin.__init__(self, test_case_server)
373
class TestingThreadingHTTPServer(test_server.TestingThreadingTCPServer,
363
SocketServer.TCPServer.__init__(self, server_address,
364
request_handler_class)
367
class TestingThreadingHTTPServer(SocketServer.ThreadingTCPServer,
374
368
TestingHTTPServerMixin):
375
369
"""A threading HTTP test server for HTTP 1.1.
378
372
server, we need an independent connection for each of them. We achieve that
379
373
by spawning a new thread for each connection.
381
376
def __init__(self, server_address, request_handler_class,
382
377
test_case_server):
383
test_server.TestingThreadingTCPServer.__init__(self, server_address,
384
request_handler_class)
385
378
TestingHTTPServerMixin.__init__(self, test_case_server)
388
class HttpServer(test_server.TestingTCPServerInAThread):
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
387
class HttpServer(transport.Server):
389
388
"""A test server for http transports.
391
390
Subclasses can provide a specific request handler.
413
412
:param protocol_version: if specified, will override the protocol
414
413
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)
415
transport.Server.__init__(self)
416
self.request_handler = request_handler
429
417
self.host = 'localhost'
431
super(HttpServer, self).__init__((self.host, self.port),
434
self.protocol_version = proto_vers
420
self.protocol_version = protocol_version
435
421
# Allows tests to verify number of GET requests issued
436
422
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)
424
def _get_httpd(self):
425
if self._httpd is None:
426
rhandler = self.request_handler
427
# Depending on the protocol version, we will create the approriate
429
if self.protocol_version is None:
430
# Use the request handler one
431
proto_vers = rhandler.protocol_version
433
# Use our own, it will be used to override the request handler
435
proto_vers = self.protocol_version
436
# Create the appropriate server for the required protocol
437
serv_cls = self.http_server_class.get(proto_vers, None)
439
raise httplib.UnknownProtocol(proto_vers)
441
self._httpd = serv_cls((self.host, self.port), rhandler, self)
442
host, self.port = self._httpd.socket.getsockname()
445
def _http_start(self):
446
"""Server thread main entry point. """
447
self._http_running = False
450
httpd = self._get_httpd()
451
self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
452
self.host, self.port)
453
self._http_running = True
455
# Whatever goes wrong, we save the exception for the main
456
# thread. Note that since we are running in a thread, no signal
457
# can be received, so we don't care about KeyboardInterrupt.
458
self._http_exception = sys.exc_info()
460
# Release the lock or the main thread will block and the whole
462
self._http_starting.release()
464
# From now on, exceptions are taken care of by the
465
# SocketServer.BaseServer or the request handler.
466
while self._http_running:
468
# Really an HTTP connection but the python framework is generic
469
# and call them requests
470
httpd.handle_request()
471
except socket.timeout:
444
474
def _get_remote_url(self, path):
445
475
path_parts = path.split(os.path.sep)
457
487
"""Capture Server log output."""
458
488
self.logs.append(format % args)
460
def start_server(self, backing_transport_server=None):
461
"""See bzrlib.transport.Server.start_server.
490
def setUp(self, backing_transport_server=None):
491
"""See bzrlib.transport.Server.setUp.
463
493
:param backing_transport_server: The transport that requests over this
464
494
protocol should be forwarded to. Note that this is currently not
465
495
supported for HTTP.
467
497
# 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)):
472
raise AssertionError(
473
"HTTPServer currently assumes local transport, got %s" %
474
backing_transport_server)
499
assert backing_transport_server is None or \
500
isinstance(backing_transport_server, local.LocalURLServer), \
501
"HTTPServer currently assumes local transport, got %s" % \
502
backing_transport_server
475
503
self._home_dir = os.getcwdu()
476
504
self._local_path_parts = self._home_dir.split(os.path.sep)
505
self._http_base_url = None
507
# Create the server thread
508
self._http_starting = threading.Lock()
509
self._http_starting.acquire()
510
self._http_thread = threading.Thread(target=self._http_start)
511
self._http_thread.setDaemon(True)
512
self._http_exception = None
513
self._http_thread.start()
515
# Wait for the server thread to start (i.e release the lock)
516
self._http_starting.acquire()
518
if self._http_exception is not None:
519
# Something went wrong during server start
520
exc_class, exc_value, exc_tb = self._http_exception
521
raise exc_class, exc_value, exc_tb
522
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)
526
"""See bzrlib.transport.Server.tearDown."""
527
self._httpd.tearDown()
528
self._http_running = False
529
# We don't need to 'self._http_thread.join()' here since the thread is
530
# a daemonic one and will be garbage collected anyway. Joining just
531
# slows us down for no added benefit.
483
533
def get_url(self):
484
534
"""See bzrlib.transport.Server.get_url."""
added
removed
bzrlib/tests/http_server.py
