40
33
return 'path %s is not in %s' % self.args
43
class TestingHTTPRequestHandler(SimpleHTTPRequestHandler):
36
class TestingHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
37
"""Handles one request.
39
A TestingHTTPRequestHandler is instantiated for every request received by
40
the associated server. Note that 'request' here is inherited from the base
41
TCPServer class, for the HTTP server it is really a connection which itself
42
will handle one or several HTTP requests.
44
# Default protocol version
45
protocol_version = 'HTTP/1.1'
47
# The Message-like class used to parse the request headers
48
MessageClass = httplib.HTTPMessage
51
SimpleHTTPServer.SimpleHTTPRequestHandler.setup(self)
52
self._cwd = self.server._home_dir
53
tcs = self.server.test_case_server
54
if tcs.protocol_version is not None:
55
# If the test server forced a protocol version, use it
56
self.protocol_version = tcs.protocol_version
45
58
def log_message(self, format, *args):
46
self.server.test_case.log('webserver - %s - - [%s] %s "%s" "%s"',
47
self.address_string(),
48
self.log_date_time_string(),
50
self.headers.get('referer', '-'),
51
self.headers.get('user-agent', '-'))
59
tcs = self.server.test_case_server
60
tcs.log('webserver - %s - - [%s] %s "%s" "%s"',
61
self.address_string(),
62
self.log_date_time_string(),
64
self.headers.get('referer', '-'),
65
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()
53
75
def handle_one_request(self):
54
76
"""Handle a single HTTP request.
56
You normally don't need to override this method; see the class
57
__doc__ string for information on how to handle specific HTTP
58
commands such as GET and POST.
78
We catch all socket errors occurring when the client close the
79
connection early to avoid polluting the test results.
61
for i in xrange(1,11): # Don't try more than 10 times
63
self.raw_requestline = self.rfile.readline()
64
except socket.error, e:
65
if e.args[0] in (errno.EAGAIN, errno.EWOULDBLOCK):
66
# omitted for now because some tests look at the log of
67
# the server and expect to see no errors. see recent
68
# email thread. -- mbp 20051021.
69
## self.log_message('EAGAIN (%d) while reading from raw_requestline' % i)
82
self._handle_one_request()
83
except socket.error, e:
84
# Any socket error should close the connection, but some errors are
85
# due to the client closing early and we don't want to pollute test
86
# results, so we raise only the others.
87
self.close_connection = 1
89
or e.args[0] not in (errno.EPIPE, errno.ECONNRESET,
90
errno.ECONNABORTED, errno.EBADF)):
75
if not self.raw_requestline:
76
self.close_connection = 1
78
if not self.parse_request(): # An error code has been sent, just exit
80
mname = 'do_' + self.command
81
if getattr(self, mname, None) is None:
82
self.send_error(501, "Unsupported method (%r)" % self.command)
84
method = getattr(self, mname)
87
_range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
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+)?$')
88
132
_tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
90
def parse_ranges(self, ranges_header):
91
"""Parse the range header value and returns ranges and tail.
93
RFC2616 14.35 says that syntactically invalid range
94
specifiers MUST be ignored. In that case, we return 0 for
95
tail and [] for ranges.
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.
99
147
if not ranges_header.startswith('bytes='):
100
148
# Syntactically invalid header
103
153
ranges_header = ranges_header[len('bytes='):]
104
154
for range_str in ranges_header.split(','):
105
# FIXME: RFC2616 says end is optional and default to file_size
106
155
range_match = self._range_regexp.match(range_str)
107
156
if range_match is not None:
108
157
start = int(range_match.group('start'))
109
end = int(range_match.group('end'))
158
end_match = range_match.group('end')
159
if end_match is None:
160
# RFC2616 says end is optional and default to file_size
111
165
# Syntactically invalid range
113
167
ranges.append((start, end))
115
169
tail_match = self._tail_regexp.match(range_str)
117
171
tail = int(tail_match.group('tail'))
119
173
# 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
def _header_line_length(self, keyword, value):
191
header_line = '%s: %s\r\n' % (keyword, value)
192
return len(header_line)
195
"""Overrides base implementation to work around a bug in python2.5."""
196
path = self.translate_path(self.path)
197
if os.path.isdir(path) and not self.path.endswith('/'):
198
# redirect browser - doing basically what apache does when
199
# DirectorySlash option is On which is quite common (braindead, but
201
self.send_response(301)
202
self.send_header("Location", self.path + "/")
203
# Indicates that the body is empty for HTTP/1.1 clients
204
self.send_header('Content-Length', '0')
208
return SimpleHTTPServer.SimpleHTTPRequestHandler.send_head(self)
123
210
def send_range_content(self, file, start, length):
140
227
def get_multiple_ranges(self, file, file_size, ranges):
141
228
self.send_response(206)
142
229
self.send_header('Accept-Ranges', 'bytes')
143
boundary = "%d" % random.randint(0,0x7FFFFFFF)
144
self.send_header("Content-Type",
145
"multipart/byteranges; boundary=%s" % boundary)
230
boundary = '%d' % random.randint(0,0x7FFFFFFF)
231
self.send_header('Content-Type',
232
'multipart/byteranges; boundary=%s' % boundary)
233
boundary_line = '--%s\r\n' % boundary
234
# Calculate the Content-Length
236
for (start, end) in ranges:
237
content_length += len(boundary_line)
238
content_length += self._header_line_length(
239
'Content-type', 'application/octet-stream')
240
content_length += self._header_line_length(
241
'Content-Range', 'bytes %d-%d/%d' % (start, end, file_size))
242
content_length += len('\r\n') # end headers
243
content_length += end - start + 1
244
content_length += len(boundary_line)
245
self.send_header('Content-length', content_length)
146
246
self.end_headers()
248
# Send the multipart body
147
249
for (start, end) in ranges:
148
self.wfile.write("--%s\r\n" % boundary)
149
self.send_header("Content-type", 'application/octet-stream')
150
self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
250
self.wfile.write(boundary_line)
251
self.send_header('Content-type', 'application/octet-stream')
252
self.send_header('Content-Range', 'bytes %d-%d/%d'
253
% (start, end, file_size))
153
254
self.end_headers()
154
255
self.send_range_content(file, start, end - start + 1)
155
self.wfile.write("--%s\r\n" % boundary)
257
self.wfile.write(boundary_line)
158
259
def do_GET(self):
159
260
"""Serve a GET request.
161
262
Handles the Range header.
265
self.server.test_case_server.GET_request_nb += 1
164
267
path = self.translate_path(self.path)
165
268
ranges_header_value = self.headers.get('Range')
166
269
if ranges_header_value is None or os.path.isdir(path):
167
270
# Let the mother class handle most cases
168
return SimpleHTTPRequestHandler.do_GET(self)
271
return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
171
274
# Always read in binary mode. Opening files in text
172
275
# mode may cause newline translations, making the
173
276
# actual size of the content transmitted *less* than
174
277
# the content-length!
175
file = open(path, 'rb')
177
280
self.send_error(404, "File not found")
180
file_size = os.fstat(file.fileno())[6]
181
tail, ranges = self.parse_ranges(ranges_header_value)
182
# Normalize tail into ranges
184
ranges.append((file_size - tail, file_size))
186
self._satisfiable_ranges = True
188
self._satisfiable_ranges = False
190
def check_range(range_specifier):
191
start, end = range_specifier
192
# RFC2616 14.35, ranges are invalid if start >= file_size
193
if start >= file_size:
194
self._satisfiable_ranges = False # Side-effect !
196
# RFC2616 14.35, end values should be truncated
197
# to file_size -1 if they exceed it
198
end = min(end, file_size - 1)
201
ranges = map(check_range, ranges)
203
if not self._satisfiable_ranges:
283
file_size = os.fstat(f.fileno())[6]
284
ranges = self._parse_ranges(ranges_header_value, file_size)
204
286
# RFC2616 14.16 and 14.35 says that when a server
205
287
# encounters unsatisfiable range specifiers, it
206
288
# SHOULD return a 416.
208
290
# FIXME: We SHOULD send a Content-Range header too,
209
291
# but the implementation of send_error does not
210
292
# allows that. So far.
214
296
if len(ranges) == 1:
215
297
(start, end) = ranges[0]
216
self.get_single_range(file, file_size, start, end)
298
self.get_single_range(f, file_size, start, end)
218
self.get_multiple_ranges(file, file_size, ranges)
221
if sys.platform == 'win32':
222
# On win32 you cannot access non-ascii filenames without
223
# decoding them into unicode first.
224
# However, under Linux, you can access bytestream paths
225
# without any problems. If this function was always active
226
# it would probably break tests when LANG=C was set
227
def translate_path(self, path):
228
"""Translate a /-separated PATH to the local filename syntax.
230
For bzr, all url paths are considered to be utf8 paths.
231
On Linux, you can access these paths directly over the bytestream
232
request, but on win32, you must decode them, and access them
235
# abandon query parameters
300
self.get_multiple_ranges(f, file_size, ranges)
303
def translate_path(self, path):
304
"""Translate a /-separated PATH to the local filename syntax.
306
If the server requires it, proxy the path before the usual translation
308
if self.server.test_case_server.proxy_requests:
309
# We need to act as a proxy and accept absolute urls,
310
# which SimpleHTTPRequestHandler (parent) is not
311
# ready for. So we just drop the protocol://host:port
312
# part in front of the request-url (because we know
313
# we would not forward the request to *another*
316
# So we do what SimpleHTTPRequestHandler.translate_path
317
# do beginning with python 2.4.3: abandon query
318
# parameters, scheme, host port, etc (which ensure we
319
# provide the right behaviour on all python versions).
236
320
path = urlparse.urlparse(path)[2]
237
path = posixpath.normpath(urllib.unquote(path))
238
path = path.decode('utf-8')
239
words = path.split('/')
240
words = filter(None, words)
321
# And now, we can apply *our* trick to proxy files
324
return self._translate_path(path)
326
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(urlutils.unquote(path))
340
path = path.decode('utf-8')
341
words = path.split('/')
342
words = filter(None, words)
344
for num, word in enumerate(words):
243
346
drive, word = os.path.splitdrive(word)
244
head, word = os.path.split(word)
245
if word in (os.curdir, os.pardir): continue
246
path = os.path.join(path, word)
250
class TestingHTTPServer(BaseHTTPServer.HTTPServer):
251
def __init__(self, server_address, RequestHandlerClass, test_case):
252
BaseHTTPServer.HTTPServer.__init__(self, server_address,
254
self.test_case = test_case
257
class HttpServer(Server):
347
head, word = os.path.split(word)
348
if word in (os.curdir, os.pardir): continue
349
path = os.path.join(path, word)
353
class TestingHTTPServerMixin:
355
def __init__(self, test_case_server):
356
# test_case_server can be used to communicate between the
357
# tests and the server (or the request handler and the
358
# server), allowing dynamic behaviors to be defined from
360
self.test_case_server = test_case_server
361
self._home_dir = test_case_server._home_dir
364
class TestingHTTPServer(test_server.TestingTCPServer, TestingHTTPServerMixin):
366
def __init__(self, server_address, request_handler_class,
368
test_server.TestingTCPServer.__init__(self, server_address,
369
request_handler_class)
370
TestingHTTPServerMixin.__init__(self, test_case_server)
373
class TestingThreadingHTTPServer(test_server.TestingThreadingTCPServer,
374
TestingHTTPServerMixin):
375
"""A threading HTTP test server for HTTP 1.1.
377
Since tests can initiate several concurrent connections to the same http
378
server, we need an independent connection for each of them. We achieve that
379
by spawning a new thread for each connection.
381
def __init__(self, server_address, request_handler_class,
383
test_server.TestingThreadingTCPServer.__init__(self, server_address,
384
request_handler_class)
385
TestingHTTPServerMixin.__init__(self, test_case_server)
388
class HttpServer(test_server.TestingTCPServerInAThread):
258
389
"""A test server for http transports.
260
391
Subclasses can provide a specific request handler.
394
# The real servers depending on the protocol
395
http_server_class = {'HTTP/1.0': TestingHTTPServer,
396
'HTTP/1.1': TestingThreadingHTTPServer,
399
# Whether or not we proxy the requests (see
400
# TestingHTTPRequestHandler.translate_path).
401
proxy_requests = False
263
403
# used to form the url that connects to this server
264
404
_url_protocol = 'http'
266
# Subclasses can provide a specific request handler
267
def __init__(self, request_handler=TestingHTTPRequestHandler):
268
Server.__init__(self)
269
self.request_handler = request_handler
271
def _get_httpd(self):
272
return TestingHTTPServer(('localhost', 0),
273
self.request_handler,
276
def _http_start(self):
278
httpd = self._get_httpd()
279
host, self.port = httpd.socket.getsockname()
280
self._http_base_url = '%s://localhost:%s/' % (self._url_protocol,
282
self._http_starting.release()
283
httpd.socket.settimeout(0.1)
285
while self._http_running:
287
httpd.handle_request()
288
except socket.timeout:
406
def __init__(self, request_handler=TestingHTTPRequestHandler,
407
protocol_version=None):
410
:param request_handler: a class that will be instantiated to handle an
411
http connection (one or several requests).
413
:param protocol_version: if specified, will override the protocol
414
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)
429
self.host = 'localhost'
431
super(HttpServer, self).__init__((self.host, self.port),
434
self.protocol_version = proto_vers
435
# Allows tests to verify number of GET requests issued
436
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)
291
444
def _get_remote_url(self, path):
292
445
path_parts = path.split(os.path.sep)
304
457
"""Capture Server log output."""
305
458
self.logs.append(format % args)
308
"""See bzrlib.transport.Server.setUp."""
460
def start_server(self, backing_transport_server=None):
461
"""See bzrlib.transport.Server.start_server.
463
:param backing_transport_server: The transport that requests over this
464
protocol should be forwarded to. Note that this is currently not
467
# 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)
309
475
self._home_dir = os.getcwdu()
310
476
self._local_path_parts = self._home_dir.split(os.path.sep)
311
self._http_starting = threading.Lock()
312
self._http_starting.acquire()
313
self._http_running = True
314
self._http_base_url = None
315
self._http_thread = threading.Thread(target=self._http_start)
316
self._http_thread.setDaemon(True)
317
self._http_thread.start()
318
# Wait for the server thread to start (i.e release the lock)
319
self._http_starting.acquire()
320
self._http_starting.release()
324
"""See bzrlib.transport.Server.tearDown."""
325
self._http_running = False
326
self._http_thread.join()
479
super(HttpServer, self).start_server()
480
self._http_base_url = '%s://%s:%s/' % (
481
self._url_protocol, self.host, self.port)
328
483
def get_url(self):
329
484
"""See bzrlib.transport.Server.get_url."""
added
removed
bzrlib/tests/http_server.py
