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
20
from SimpleHTTPServer import SimpleHTTPRequestHandler
23
import SimpleHTTPServer
27
from bzrlib import urlutils
28
from bzrlib.tests import test_server
31
from bzrlib.transport import Server
32
from bzrlib.transport.local import LocalURLServer
35
class WebserverNotAvailable(Exception):
31
39
class BadWebserverPath(ValueError):
33
41
return 'path %s is not in %s' % self.args
36
class TestingHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
44
class TestingHTTPRequestHandler(SimpleHTTPRequestHandler):
37
45
"""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.
47
A TestingHTTPRequestHandler is instantiated for every request
48
received by the associated server.
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
58
51
def log_message(self, format, *args):
59
52
tcs = self.server.test_case_server
82
67
self._handle_one_request()
83
68
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.
70
and e.args[0] in (errno.EPIPE, errno.ECONNRESET,
71
errno.ECONNABORTED,)):
72
self.close_connection = 1
77
def _handle_one_request(self):
79
Request handling as defined in the base class.
81
You normally don't need to override this method; see the class
82
__doc__ string for information on how to handle specific HTTP
83
commands such as GET and POST.
85
On some platforms, notably OS X, a lot of EAGAIN (resource temporary
86
unavailable) occur. We retry silently at most 10 times.
88
for i in xrange(1,11): # Don't try more than 10 times
90
self.raw_requestline = self.rfile.readline()
91
except socket.error, e:
92
if e.args[0] in (errno.EAGAIN, errno.EWOULDBLOCK):
93
# omitted for now because some tests look at the log of
94
# the server and expect to see no errors. see recent
95
# email thread. -- mbp 20051021.
96
## self.log_message('EAGAIN (%d) while reading from raw_requestline' % i)
102
if not self.raw_requestline:
87
103
self.close_connection = 1
89
or e.args[0] not in (errno.EPIPE, errno.ECONNRESET,
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+)?$')
105
if not self.parse_request(): # An error code has been sent, just exit
107
mname = 'do_' + self.command
108
if getattr(self, mname, None) is None:
109
self.send_error(501, "Unsupported method (%r)" % self.command)
111
method = getattr(self, mname)
114
_range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
132
115
_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.
117
def parse_ranges(self, ranges_header):
118
"""Parse the range header value and returns ranges and tail.
120
RFC2616 14.35 says that syntactically invalid range
121
specifiers MUST be ignored. In that case, we return 0 for
122
tail and [] for ranges.
147
126
if not ranges_header.startswith('bytes='):
148
127
# Syntactically invalid header
153
130
ranges_header = ranges_header[len('bytes='):]
154
131
for range_str in ranges_header.split(','):
132
# FIXME: RFC2616 says end is optional and default to file_size
155
133
range_match = self._range_regexp.match(range_str)
156
134
if range_match is not None:
157
135
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
136
end = int(range_match.group('end'))
165
138
# Syntactically invalid range
167
140
ranges.append((start, end))
169
142
tail_match = self._tail_regexp.match(range_str)
171
144
tail = int(tail_match.group('tail'))
173
146
# 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)
210
150
def send_range_content(self, file, start, length):
227
167
def get_multiple_ranges(self, file, file_size, ranges):
228
168
self.send_response(206)
229
169
self.send_header('Accept-Ranges', 'bytes')
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)
170
boundary = "%d" % random.randint(0,0x7FFFFFFF)
171
self.send_header("Content-Type",
172
"multipart/byteranges; boundary=%s" % boundary)
246
173
self.end_headers()
248
# Send the multipart body
249
174
for (start, end) in ranges:
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))
175
self.wfile.write("--%s\r\n" % boundary)
176
self.send_header("Content-type", 'application/octet-stream')
177
self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
254
180
self.end_headers()
255
181
self.send_range_content(file, start, end - start + 1)
257
self.wfile.write(boundary_line)
182
self.wfile.write("--%s\r\n" % boundary)
259
184
def do_GET(self):
260
185
"""Serve a GET request.
262
187
Handles the Range header.
265
self.server.test_case_server.GET_request_nb += 1
267
190
path = self.translate_path(self.path)
268
191
ranges_header_value = self.headers.get('Range')
269
192
if ranges_header_value is None or os.path.isdir(path):
270
193
# Let the mother class handle most cases
271
return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
194
return SimpleHTTPRequestHandler.do_GET(self)
274
197
# Always read in binary mode. Opening files in text
275
198
# mode may cause newline translations, making the
276
199
# actual size of the content transmitted *less* than
277
200
# the content-length!
201
file = open(path, 'rb')
280
203
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)
206
file_size = os.fstat(file.fileno())[6]
207
tail, ranges = self.parse_ranges(ranges_header_value)
208
# Normalize tail into ranges
210
ranges.append((file_size - tail, file_size))
212
self._satisfiable_ranges = True
214
self._satisfiable_ranges = False
216
def check_range(range_specifier):
217
start, end = range_specifier
218
# RFC2616 14.35, ranges are invalid if start >= file_size
219
if start >= file_size:
220
self._satisfiable_ranges = False # Side-effect !
222
# RFC2616 14.35, end values should be truncated
223
# to file_size -1 if they exceed it
224
end = min(end, file_size - 1)
227
ranges = map(check_range, ranges)
229
if not self._satisfiable_ranges:
286
230
# RFC2616 14.16 and 14.35 says that when a server
287
231
# encounters unsatisfiable range specifiers, it
288
232
# SHOULD return a 416.
290
234
# FIXME: We SHOULD send a Content-Range header too,
291
235
# but the implementation of send_error does not
292
236
# allows that. So far.
324
268
return self._translate_path(path)
326
270
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):
271
return SimpleHTTPRequestHandler.translate_path(self, path)
273
if sys.platform == 'win32':
274
# On win32 you cannot access non-ascii filenames without
275
# decoding them into unicode first.
276
# However, under Linux, you can access bytestream paths
277
# without any problems. If this function was always active
278
# it would probably break tests when LANG=C was set
279
def _translate_path(self, path):
280
"""Translate a /-separated PATH to the local filename syntax.
282
For bzr, all url paths are considered to be utf8 paths.
283
On Linux, you can access these paths directly over the bytestream
284
request, but on win32, you must decode them, and access them
287
# abandon query parameters
288
path = urlparse.urlparse(path)[2]
289
path = posixpath.normpath(urllib.unquote(path))
290
path = path.decode('utf-8')
291
words = path.split('/')
292
words = filter(None, words)
346
295
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)
353
class TestingHTTPServerMixin:
355
def __init__(self, test_case_server):
296
head, word = os.path.split(word)
297
if word in (os.curdir, os.pardir): continue
298
path = os.path.join(path, word)
302
class TestingHTTPServer(BaseHTTPServer.HTTPServer):
304
def __init__(self, server_address, RequestHandlerClass,
306
BaseHTTPServer.HTTPServer.__init__(self, server_address,
356
308
# test_case_server can be used to communicate between the
357
309
# tests and the server (or the request handler and the
358
310
# server), allowing dynamic behaviors to be defined from
359
311
# the tests cases.
360
312
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):
315
class HttpServer(Server):
389
316
"""A test server for http transports.
391
318
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
321
# Whether or not we proxy the requests (see
400
322
# TestingHTTPRequestHandler.translate_path).
401
323
proxy_requests = False
403
325
# used to form the url that connects to this server
404
326
_url_protocol = 'http'
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)
328
# Subclasses can provide a specific request handler
329
def __init__(self, request_handler=TestingHTTPRequestHandler):
330
Server.__init__(self)
331
self.request_handler = request_handler
429
332
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)
336
def _get_httpd(self):
337
if self._httpd is None:
338
self._httpd = TestingHTTPServer((self.host, self.port),
339
self.request_handler,
341
host, self.port = self._httpd.socket.getsockname()
344
def _http_start(self):
345
httpd = self._get_httpd()
346
self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
349
httpd.socket.settimeout(0.1)
350
self._http_starting.release()
352
while self._http_running:
354
httpd.handle_request()
355
except socket.timeout:
444
358
def _get_remote_url(self, path):
445
359
path_parts = path.split(os.path.sep)
457
371
"""Capture Server log output."""
458
372
self.logs.append(format % args)
460
def start_server(self, backing_transport_server=None):
461
"""See bzrlib.transport.Server.start_server.
374
def setUp(self, backing_transport_server=None):
375
"""See bzrlib.transport.Server.setUp.
463
377
:param backing_transport_server: The transport that requests over this
464
378
protocol should be forwarded to. Note that this is currently not
465
379
supported for HTTP.
467
381
# 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)
383
assert backing_transport_server is None or \
384
isinstance(backing_transport_server, LocalURLServer), \
385
"HTTPServer currently assumes local transport, got %s" % \
386
backing_transport_server
475
387
self._home_dir = os.getcwdu()
476
388
self._local_path_parts = self._home_dir.split(os.path.sep)
389
self._http_starting = threading.Lock()
390
self._http_starting.acquire()
391
self._http_running = True
392
self._http_base_url = None
393
self._http_thread = threading.Thread(target=self._http_start)
394
self._http_thread.setDaemon(True)
395
self._http_thread.start()
396
# Wait for the server thread to start (i.e release the lock)
397
self._http_starting.acquire()
398
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)
402
"""See bzrlib.transport.Server.tearDown."""
403
self._httpd.server_close()
404
self._http_running = False
405
self._http_thread.join()
483
407
def get_url(self):
484
408
"""See bzrlib.transport.Server.get_url."""
added
removed
bzrlib/tests/HttpServer.py
