1
# Copyright (C) 2006-2011 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
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
19
import http.client as http_client
20
import http.server as http_server
22
import httplib as http_client
23
import SimpleHTTPServer as http_server
30
from urlparse import urlparse
32
from urllib.parse import urlparse
38
from . import test_server
41
class BadWebserverPath(ValueError):
43
return 'path %s is not in %s' % self.args
46
class TestingHTTPRequestHandler(http_server.SimpleHTTPRequestHandler):
47
"""Handles one request.
49
A TestingHTTPRequestHandler is instantiated for every request received by
50
the associated server. Note that 'request' here is inherited from the base
51
TCPServer class, for the HTTP server it is really a connection which itself
52
will handle one or several HTTP requests.
54
# Default protocol version
55
protocol_version = 'HTTP/1.1'
57
# The Message-like class used to parse the request headers
58
MessageClass = http_client.HTTPMessage
61
http_server.SimpleHTTPRequestHandler.setup(self)
62
self._cwd = self.server._home_dir
63
tcs = self.server.test_case_server
64
if tcs.protocol_version is not None:
65
# If the test server forced a protocol version, use it
66
self.protocol_version = tcs.protocol_version
68
def log_message(self, format, *args):
69
tcs = self.server.test_case_server
70
tcs.log('webserver - %s - - [%s] %s "%s" "%s"',
71
self.address_string(),
72
self.log_date_time_string(),
74
self.headers.get('referer', '-'),
75
self.headers.get('user-agent', '-'))
77
def handle_one_request(self):
78
"""Handle a single HTTP request.
80
We catch all socket errors occurring when the client close the
81
connection early to avoid polluting the test results.
84
self._handle_one_request()
85
except socket.error as e:
86
# Any socket error should close the connection, but some errors are
87
# due to the client closing early and we don't want to pollute test
88
# results, so we raise only the others.
89
self.close_connection = 1
91
or e.args[0] not in (errno.EPIPE, errno.ECONNRESET,
92
errno.ECONNABORTED, errno.EBADF)):
95
error_content_type = 'text/plain'
96
error_message_format = '''\
101
def send_error(self, code, message=None):
102
"""Send and log an error reply.
104
We redefine the python-provided version to be able to set a
105
``Content-Length`` header as some http/1.1 clients complain otherwise
108
:param code: The HTTP error code.
110
:param message: The explanation of the error code, Defaults to a short
116
message = self.responses[code][0]
119
self.log_error("code %d, message %s", code, message)
120
content = (self.error_message_format %
121
{'code': code, 'message': message})
122
self.send_response(code, message)
123
self.send_header("Content-Type", self.error_content_type)
124
self.send_header("Content-Length", "%d" % len(content))
125
self.send_header('Connection', 'close')
127
if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
128
self.wfile.write(content)
130
def _handle_one_request(self):
131
http_server.SimpleHTTPRequestHandler.handle_one_request(self)
133
_range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)?$')
134
_tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
136
def _parse_ranges(self, ranges_header, file_size):
137
"""Parse the range header value and returns ranges.
139
RFC2616 14.35 says that syntactically invalid range specifiers MUST be
140
ignored. In that case, we return None instead of a range list.
142
:param ranges_header: The 'Range' header value.
144
:param file_size: The size of the requested file.
146
:return: A list of (start, end) tuples or None if some invalid range
147
specifier is encountered.
149
if not ranges_header.startswith('bytes='):
150
# Syntactically invalid header
155
ranges_header = ranges_header[len('bytes='):]
156
for range_str in ranges_header.split(','):
157
range_match = self._range_regexp.match(range_str)
158
if range_match is not None:
159
start = int(range_match.group('start'))
160
end_match = range_match.group('end')
161
if end_match is None:
162
# RFC2616 says end is optional and default to file_size
167
# Syntactically invalid range
169
ranges.append((start, end))
171
tail_match = self._tail_regexp.match(range_str)
172
if tail_match is not None:
173
tail = int(tail_match.group('tail'))
175
# Syntactically invalid range
178
# Normalize tail into ranges
179
ranges.append((max(0, file_size - tail), file_size))
182
for start, end in ranges:
183
if start >= file_size:
184
# RFC2616 14.35, ranges are invalid if start >= file_size
186
# RFC2616 14.35, end values should be truncated
187
# to file_size -1 if they exceed it
188
end = min(end, file_size - 1)
189
checked_ranges.append((start, end))
190
return checked_ranges
192
def _header_line_length(self, keyword, value):
193
header_line = '%s: %s\r\n' % (keyword, value)
194
return len(header_line)
197
"""Overrides base implementation to work around a bug in python2.5."""
198
path = self.translate_path(self.path)
199
if os.path.isdir(path) and not self.path.endswith('/'):
200
# redirect browser - doing basically what apache does when
201
# DirectorySlash option is On which is quite common (braindead, but
203
self.send_response(301)
204
self.send_header("Location", self.path + "/")
205
# Indicates that the body is empty for HTTP/1.1 clients
206
self.send_header('Content-Length', '0')
210
return http_server.SimpleHTTPRequestHandler.send_head(self)
212
def send_range_content(self, file, start, length):
214
self.wfile.write(file.read(length))
216
def get_single_range(self, file, file_size, start, end):
217
self.send_response(206)
218
length = end - start + 1
219
self.send_header('Accept-Ranges', 'bytes')
220
self.send_header("Content-Length", "%d" % length)
222
self.send_header("Content-Type", 'application/octet-stream')
223
self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
227
self.send_range_content(file, start, length)
229
def get_multiple_ranges(self, file, file_size, ranges):
230
self.send_response(206)
231
self.send_header('Accept-Ranges', 'bytes')
232
boundary = '%d' % random.randint(0, 0x7FFFFFFF)
233
self.send_header('Content-Type',
234
'multipart/byteranges; boundary=%s' % boundary)
235
boundary_line = '--%s\r\n' % boundary
236
# Calculate the Content-Length
238
for (start, end) in ranges:
239
content_length += len(boundary_line)
240
content_length += self._header_line_length(
241
'Content-type', 'application/octet-stream')
242
content_length += self._header_line_length(
243
'Content-Range', 'bytes %d-%d/%d' % (start, end, file_size))
244
content_length += len('\r\n') # end headers
245
content_length += end - start + 1
246
content_length += len(boundary_line)
247
self.send_header('Content-length', content_length)
250
# Send the multipart body
251
for (start, end) in ranges:
252
self.wfile.write(boundary_line)
253
self.send_header('Content-type', 'application/octet-stream')
254
self.send_header('Content-Range', 'bytes %d-%d/%d'
255
% (start, end, file_size))
257
self.send_range_content(file, start, end - start + 1)
259
self.wfile.write(boundary_line)
262
"""Serve a GET request.
264
Handles the Range header.
267
self.server.test_case_server.GET_request_nb += 1
269
path = self.translate_path(self.path)
270
ranges_header_value = self.headers.get('Range')
271
if ranges_header_value is None or os.path.isdir(path):
272
# Let the mother class handle most cases
273
return http_server.SimpleHTTPRequestHandler.do_GET(self)
276
# Always read in binary mode. Opening files in text
277
# mode may cause newline translations, making the
278
# actual size of the content transmitted *less* than
279
# the content-length!
282
self.send_error(404, "File not found")
285
file_size = os.fstat(f.fileno())[6]
286
ranges = self._parse_ranges(ranges_header_value, file_size)
288
# RFC2616 14.16 and 14.35 says that when a server
289
# encounters unsatisfiable range specifiers, it
290
# SHOULD return a 416.
292
# FIXME: We SHOULD send a Content-Range header too,
293
# but the implementation of send_error does not
294
# allows that. So far.
295
self.send_error(416, "Requested range not satisfiable")
299
(start, end) = ranges[0]
300
self.get_single_range(f, file_size, start, end)
302
self.get_multiple_ranges(f, file_size, ranges)
305
def translate_path(self, path):
306
"""Translate a /-separated PATH to the local filename syntax.
308
If the server requires it, proxy the path before the usual translation
310
if self.server.test_case_server.proxy_requests:
311
# We need to act as a proxy and accept absolute urls,
312
# which SimpleHTTPRequestHandler (parent) is not
313
# ready for. So we just drop the protocol://host:port
314
# part in front of the request-url (because we know
315
# we would not forward the request to *another*
318
# So we do what SimpleHTTPRequestHandler.translate_path
319
# do beginning with python 2.4.3: abandon query
320
# parameters, scheme, host port, etc (which ensure we
321
# provide the right behaviour on all python versions).
322
path = urlparse(path)[2]
323
# And now, we can apply *our* trick to proxy files
326
return self._translate_path(path)
328
def _translate_path(self, path):
329
"""Translate a /-separated PATH to the local filename syntax.
331
Note that we're translating http URLs here, not file URLs.
332
The URL root location is the server's startup directory.
333
Components that mean special things to the local file system
334
(e.g. drive or directory names) are ignored. (XXX They should
335
probably be diagnosed.)
337
Override from python standard library to stop it calling os.getcwd()
339
# abandon query parameters
340
path = urlparse(path)[2]
341
path = posixpath.normpath(urlutils.unquote(path))
342
path = path.decode('utf-8')
343
words = path.split('/')
345
for num, word in enumerate(w for w in words if w):
347
drive, word = os.path.splitdrive(word)
348
head, word = os.path.split(word)
349
if word in (os.curdir, os.pardir): continue
350
path = os.path.join(path, word)
354
class TestingHTTPServerMixin:
356
def __init__(self, test_case_server):
357
# test_case_server can be used to communicate between the
358
# tests and the server (or the request handler and the
359
# server), allowing dynamic behaviors to be defined from
361
self.test_case_server = test_case_server
362
self._home_dir = test_case_server._home_dir
365
class TestingHTTPServer(test_server.TestingTCPServer, TestingHTTPServerMixin):
367
def __init__(self, server_address, request_handler_class,
369
test_server.TestingTCPServer.__init__(self, server_address,
370
request_handler_class)
371
TestingHTTPServerMixin.__init__(self, test_case_server)
374
class TestingThreadingHTTPServer(test_server.TestingThreadingTCPServer,
375
TestingHTTPServerMixin):
376
"""A threading HTTP test server for HTTP 1.1.
378
Since tests can initiate several concurrent connections to the same http
379
server, we need an independent connection for each of them. We achieve that
380
by spawning a new thread for each connection.
382
def __init__(self, server_address, request_handler_class,
384
test_server.TestingThreadingTCPServer.__init__(self, server_address,
385
request_handler_class)
386
TestingHTTPServerMixin.__init__(self, test_case_server)
389
class HttpServer(test_server.TestingTCPServerInAThread):
390
"""A test server for http transports.
392
Subclasses can provide a specific request handler.
395
# The real servers depending on the protocol
396
http_server_class = {'HTTP/1.0': TestingHTTPServer,
397
'HTTP/1.1': TestingThreadingHTTPServer,
400
# Whether or not we proxy the requests (see
401
# TestingHTTPRequestHandler.translate_path).
402
proxy_requests = False
404
# used to form the url that connects to this server
405
_url_protocol = 'http'
407
def __init__(self, request_handler=TestingHTTPRequestHandler,
408
protocol_version=None):
411
:param request_handler: a class that will be instantiated to handle an
412
http connection (one or several requests).
414
:param protocol_version: if specified, will override the protocol
415
version of the request handler.
417
# Depending on the protocol version, we will create the approriate
419
if protocol_version is None:
420
# Use the request handler one
421
proto_vers = request_handler.protocol_version
423
# Use our own, it will be used to override the request handler
425
proto_vers = protocol_version
426
# Get the appropriate server class for the required protocol
427
serv_cls = self.http_server_class.get(proto_vers, None)
429
raise http_client.UnknownProtocol(proto_vers)
430
self.host = 'localhost'
432
super(HttpServer, self).__init__((self.host, self.port),
435
self.protocol_version = proto_vers
436
# Allows tests to verify number of GET requests issued
437
self.GET_request_nb = 0
438
self._http_base_url = None
441
def create_server(self):
442
return self.server_class(
443
(self.host, self.port), self.request_handler_class, self)
445
def _get_remote_url(self, path):
446
path_parts = path.split(os.path.sep)
447
if os.path.isabs(path):
448
if path_parts[:len(self._local_path_parts)] != \
449
self._local_path_parts:
450
raise BadWebserverPath(path, self.test_dir)
451
remote_path = '/'.join(path_parts[len(self._local_path_parts):])
453
remote_path = '/'.join(path_parts)
455
return self._http_base_url + remote_path
457
def log(self, format, *args):
458
"""Capture Server log output."""
459
self.logs.append(format % args)
461
def start_server(self, backing_transport_server=None):
462
"""See breezy.transport.Server.start_server.
464
:param backing_transport_server: The transport that requests over this
465
protocol should be forwarded to. Note that this is currently not
468
# XXX: TODO: make the server back onto vfs_server rather than local
470
if not (backing_transport_server is None
471
or isinstance(backing_transport_server,
472
test_server.LocalURLServer)):
473
raise AssertionError(
474
"HTTPServer currently assumes local transport, got %s" %
475
backing_transport_server)
476
self._home_dir = osutils.getcwd()
477
self._local_path_parts = self._home_dir.split(os.path.sep)
480
super(HttpServer, self).start_server()
481
self._http_base_url = '%s://%s:%s/' % (
482
self._url_protocol, self.host, self.port)
485
"""See breezy.transport.Server.get_url."""
486
return self._get_remote_url(self._home_dir)
488
def get_bogus_url(self):
489
"""See breezy.transport.Server.get_bogus_url."""
490
# this is chosen to try to prevent trouble with proxies, weird dns,
492
return self._url_protocol + '://127.0.0.1:1/'
added
removed
breezy/tests/http_server.py
