1
# Copyright (C) 2006 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20
from SimpleHTTPServer import SimpleHTTPRequestHandler
31
from bzrlib.transport import Server
34
class WebserverNotAvailable(Exception):
38
class BadWebserverPath(ValueError):
40
return 'path %s is not in %s' % self.args
43
class TestingHTTPRequestHandler(SimpleHTTPRequestHandler):
45
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', '-'))
53
def handle_one_request(self):
54
"""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.
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)
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+)$')
88
_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.
99
if not ranges_header.startswith('bytes='):
100
# Syntactically invalid header
103
ranges_header = ranges_header[len('bytes='):]
104
for range_str in ranges_header.split(','):
105
# FIXME: RFC2616 says end is optional and default to file_size
106
range_match = self._range_regexp.match(range_str)
107
if range_match is not None:
108
start = int(range_match.group('start'))
109
end = int(range_match.group('end'))
111
# Syntactically invalid range
113
ranges.append((start, end))
115
tail_match = self._tail_regexp.match(range_str)
116
if tail_match is not None:
117
tail = int(tail_match.group('tail'))
119
# Syntactically invalid range
123
def send_range_content(self, file, start, length):
125
self.wfile.write(file.read(length))
127
def get_single_range(self, file, file_size, start, end):
128
self.send_response(206)
129
length = end - start + 1
130
self.send_header('Accept-Ranges', 'bytes')
131
self.send_header("Content-Length", "%d" % length)
133
self.send_header("Content-Type", 'application/octet-stream')
134
self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
138
self.send_range_content(file, start, length)
140
def get_multiple_ranges(self, file, file_size, ranges):
141
self.send_response(206)
142
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)
147
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,
154
self.send_range_content(file, start, end - start + 1)
155
self.wfile.write("--%s\r\n" % boundary)
158
"""Serve a GET request.
160
Handles the Range header.
163
path = self.translate_path(self.path)
164
ranges_header_value = self.headers.get('Range')
165
if ranges_header_value is None or os.path.isdir(path):
166
# Let the mother class handle most cases
167
return SimpleHTTPRequestHandler.do_GET(self)
170
# Always read in binary mode. Opening files in text
171
# mode may cause newline translations, making the
172
# actual size of the content transmitted *less* than
173
# the content-length!
174
file = open(path, 'rb')
176
self.send_error(404, "File not found")
179
file_size = os.fstat(file.fileno())[6]
180
tail, ranges = self.parse_ranges(ranges_header_value)
181
# Normalize tail into ranges
183
ranges.append((file_size - tail, file_size))
185
self._satisfiable_ranges = True
187
self._satisfiable_ranges = False
189
def check_range(range_specifier):
190
start, end = range_specifier
191
# RFC2616 14.35, ranges are invalid if start >= file_size
192
if start >= file_size:
193
self._satisfiable_ranges = False # Side-effect !
195
# RFC2616 14.35, end values should be truncated
196
# to file_size -1 if they exceed it
197
end = min(end, file_size - 1)
200
ranges = map(check_range, ranges)
202
if not self._satisfiable_ranges:
203
# RFC2616 14.16 and 14.35 says that when a server
204
# encounters unsatisfiable range specifiers, it
205
# SHOULD return a 416.
207
# FIXME: We SHOULD send a Content-Range header too,
208
# but the implementation of send_error does not
209
# allows that. So far.
210
self.send_error(416, "Requested range not satisfiable")
214
(start, end) = ranges[0]
215
self.get_single_range(file, file_size, start, end)
217
self.get_multiple_ranges(file, file_size, ranges)
220
if sys.platform == 'win32':
221
# On win32 you cannot access non-ascii filenames without
222
# decoding them into unicode first.
223
# However, under Linux, you can access bytestream paths
224
# without any problems. If this function was always active
225
# it would probably break tests when LANG=C was set
226
def translate_path(self, path):
227
"""Translate a /-separated PATH to the local filename syntax.
229
For bzr, all url paths are considered to be utf8 paths.
230
On Linux, you can access these paths directly over the bytestream
231
request, but on win32, you must decode them, and access them
234
# abandon query parameters
235
path = urlparse.urlparse(path)[2]
236
path = posixpath.normpath(urllib.unquote(path))
237
path = path.decode('utf-8')
238
words = path.split('/')
239
words = filter(None, words)
242
drive, word = os.path.splitdrive(word)
243
head, word = os.path.split(word)
244
if word in (os.curdir, os.pardir): continue
245
path = os.path.join(path, word)
249
class TestingHTTPServer(BaseHTTPServer.HTTPServer):
250
def __init__(self, server_address, RequestHandlerClass, test_case):
251
BaseHTTPServer.HTTPServer.__init__(self, server_address,
253
self.test_case = test_case
256
class HttpServer(Server):
257
"""A test server for http transports.
259
Subclasses can provide a specific request handler.
262
# used to form the url that connects to this server
263
_url_protocol = 'http'
265
# Subclasses can provide a specific request handler
266
def __init__(self, request_handler=TestingHTTPRequestHandler):
267
Server.__init__(self)
268
self.request_handler = request_handler
269
self.host = 'localhost'
273
def _get_httpd(self):
274
if self._httpd is None:
275
self._httpd = TestingHTTPServer((self.host, self.port),
276
self.request_handler,
278
host, self.port = self._httpd.socket.getsockname()
281
def _http_start(self):
282
httpd = self._get_httpd()
283
self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
286
self._http_starting.release()
287
httpd.socket.settimeout(0.1)
289
while self._http_running:
291
httpd.handle_request()
292
except socket.timeout:
295
def _get_remote_url(self, path):
296
path_parts = path.split(os.path.sep)
297
if os.path.isabs(path):
298
if path_parts[:len(self._local_path_parts)] != \
299
self._local_path_parts:
300
raise BadWebserverPath(path, self.test_dir)
301
remote_path = '/'.join(path_parts[len(self._local_path_parts):])
303
remote_path = '/'.join(path_parts)
305
return self._http_base_url + remote_path
307
def log(self, format, *args):
308
"""Capture Server log output."""
309
self.logs.append(format % args)
312
"""See bzrlib.transport.Server.setUp."""
313
self._home_dir = os.getcwdu()
314
self._local_path_parts = self._home_dir.split(os.path.sep)
315
self._http_starting = threading.Lock()
316
self._http_starting.acquire()
317
self._http_running = True
318
self._http_base_url = None
319
self._http_thread = threading.Thread(target=self._http_start)
320
self._http_thread.setDaemon(True)
321
self._http_thread.start()
322
# Wait for the server thread to start (i.e release the lock)
323
self._http_starting.acquire()
324
self._http_starting.release()
328
"""See bzrlib.transport.Server.tearDown."""
329
self._http_running = False
330
self._http_thread.join()
333
"""See bzrlib.transport.Server.get_url."""
334
return self._get_remote_url(self._home_dir)
336
def get_bogus_url(self):
337
"""See bzrlib.transport.Server.get_bogus_url."""
338
# this is chosen to try to prevent trouble with proxies, weird dns,
340
return 'http://127.0.0.1:1/'
343
class HttpServer_urllib(HttpServer):
344
"""Subclass of HttpServer that gives http+urllib urls.
346
This is for use in testing: connections to this server will always go
347
through urllib where possible.
350
# urls returned by this server should require the urllib client impl
351
_url_protocol = 'http+urllib'
354
class HttpServer_PyCurl(HttpServer):
355
"""Subclass of HttpServer that gives http+pycurl urls.
357
This is for use in testing: connections to this server will always go
358
through pycurl where possible.
361
# We don't care about checking the pycurl availability as
362
# this server will be required only when pycurl is present
364
# urls returned by this server should require the pycurl client impl
365
_url_protocol = 'http+pycurl'
added
removed
bzrlib/tests/HttpServer.py
