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"""
94
assert ranges_header.startswith('bytes=')
95
ranges_header = ranges_header[len('bytes='):]
96
for range_str in ranges_header.split(','):
97
range_match = self._range_regexp.match(range_str)
98
if range_match is not None:
99
ranges.append((int(range_match.group('start')),
100
int(range_match.group('end'))))
102
tail_match = self._tail_regexp.match(range_str)
103
if tail_match is not None:
104
tail = int(tail_match.group('tail'))
107
def send_range_content(self, file, start, length):
109
self.wfile.write(file.read(length))
111
def get_single_range(self, file, file_size, start, end):
112
self.send_response(206)
113
length = end - start + 1
114
self.send_header('Accept-Ranges', 'bytes')
115
self.send_header("Content-Length", "%d" % length)
117
self.send_header("Content-Type", 'application/octet-stream')
118
self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
122
self.send_range_content(file, start, length)
124
def get_multiple_ranges(self, file, file_size, ranges):
125
self.send_response(206)
126
self.send_header('Accept-Ranges', 'bytes')
127
boundary = "%d" % random.randint(0,0x7FFFFFFF)
128
self.send_header("Content-Type",
129
"multipart/byteranges; boundary=%s" % boundary)
131
for (start, end) in ranges:
132
self.wfile.write("--%s\r\n" % boundary)
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, end - start + 1)
139
self.wfile.write("--%s\r\n" % boundary)
143
"""Serve a GET request.
145
Handles the Range header.
148
path = self.translate_path(self.path)
149
ranges_header_value = self.headers.get('Range')
150
if ranges_header_value is None or os.path.isdir(path):
151
# Let the mother class handle most cases
152
return SimpleHTTPRequestHandler.do_GET(self)
155
# Always read in binary mode. Opening files in text
156
# mode may cause newline translations, making the
157
# actual size of the content transmitted *less* than
158
# the content-length!
159
file = open(path, 'rb')
161
self.send_error(404, "File not found")
164
file_size = os.fstat(file.fileno())[6]
165
tail, ranges = self.parse_ranges(ranges_header_value)
166
# Normalize tail into ranges
168
ranges.append((file_size - tail, file_size))
174
for (start, end) in ranges:
175
if start >= file_size or end >= file_size:
179
# RFC2616 14.35 says that invalid Range headers must
180
# be ignored. If they are, the whole file should be
181
# returned as though no Range header was present. If
182
# they aren't, the server should return a 416 error.
183
# FIXME: per 14.35, ranges are only invalid if start > end.
184
# end values should be truncated to file_size -1 if they exceed it.
185
# only start values >= file_size should produce a 416.
187
self.send_error(416, "Requested range not satisfiable")
191
(start, end) = ranges[0]
192
self.get_single_range(file, file_size, start, end)
194
self.get_multiple_ranges(file, file_size, ranges)
197
if sys.platform == 'win32':
198
# On win32 you cannot access non-ascii filenames without
199
# decoding them into unicode first.
200
# However, under Linux, you can access bytestream paths
201
# without any problems. If this function was always active
202
# it would probably break tests when LANG=C was set
203
def translate_path(self, path):
204
"""Translate a /-separated PATH to the local filename syntax.
206
For bzr, all url paths are considered to be utf8 paths.
207
On Linux, you can access these paths directly over the bytestream
208
request, but on win32, you must decode them, and access them
211
# abandon query parameters
212
path = urlparse.urlparse(path)[2]
213
path = posixpath.normpath(urllib.unquote(path))
214
path = path.decode('utf-8')
215
words = path.split('/')
216
words = filter(None, words)
219
drive, word = os.path.splitdrive(word)
220
head, word = os.path.split(word)
221
if word in (os.curdir, os.pardir): continue
222
path = os.path.join(path, word)
226
class TestingHTTPServer(BaseHTTPServer.HTTPServer):
227
def __init__(self, server_address, RequestHandlerClass, test_case):
228
BaseHTTPServer.HTTPServer.__init__(self, server_address,
230
self.test_case = test_case
233
class HttpServer(Server):
234
"""A test server for http transports.
236
Subclasses can provide a specific request handler.
239
# used to form the url that connects to this server
240
_url_protocol = 'http'
242
# Subclasses can provide a specific request handler
243
def __init__(self, request_handler=TestingHTTPRequestHandler):
244
Server.__init__(self)
245
self.request_handler = request_handler
247
def _get_httpd(self):
248
return TestingHTTPServer(('localhost', 0),
249
self.request_handler,
252
def _http_start(self):
254
httpd = self._get_httpd()
255
host, port = httpd.socket.getsockname()
256
self._http_base_url = '%s://localhost:%s/' % (self._url_protocol, port)
257
self._http_starting.release()
258
httpd.socket.settimeout(0.1)
260
while self._http_running:
262
httpd.handle_request()
263
except socket.timeout:
266
def _get_remote_url(self, path):
267
path_parts = path.split(os.path.sep)
268
if os.path.isabs(path):
269
if path_parts[:len(self._local_path_parts)] != \
270
self._local_path_parts:
271
raise BadWebserverPath(path, self.test_dir)
272
remote_path = '/'.join(path_parts[len(self._local_path_parts):])
274
remote_path = '/'.join(path_parts)
276
self._http_starting.acquire()
277
self._http_starting.release()
278
return self._http_base_url + remote_path
280
def log(self, format, *args):
281
"""Capture Server log output."""
282
self.logs.append(format % args)
285
"""See bzrlib.transport.Server.setUp."""
286
self._home_dir = os.getcwdu()
287
self._local_path_parts = self._home_dir.split(os.path.sep)
288
self._http_starting = threading.Lock()
289
self._http_starting.acquire()
290
self._http_running = True
291
self._http_base_url = None
292
self._http_thread = threading.Thread(target=self._http_start)
293
self._http_thread.setDaemon(True)
294
self._http_thread.start()
295
self._http_proxy = os.environ.get("http_proxy")
296
if self._http_proxy is not None:
297
del os.environ["http_proxy"]
301
"""See bzrlib.transport.Server.tearDown."""
302
self._http_running = False
303
self._http_thread.join()
304
if self._http_proxy is not None:
306
os.environ["http_proxy"] = self._http_proxy
309
"""See bzrlib.transport.Server.get_url."""
310
return self._get_remote_url(self._home_dir)
312
def get_bogus_url(self):
313
"""See bzrlib.transport.Server.get_bogus_url."""
314
# this is chosen to try to prevent trouble with proxies, weird dns,
316
return 'http://127.0.0.1:1/'
319
class HttpServer_urllib(HttpServer):
320
"""Subclass of HttpServer that gives http+urllib urls.
322
This is for use in testing: connections to this server will always go
323
through urllib where possible.
326
# urls returned by this server should require the urllib client impl
327
_url_protocol = 'http+urllib'
330
class HttpServer_PyCurl(HttpServer):
331
"""Subclass of HttpServer that gives http+pycurl urls.
333
This is for use in testing: connections to this server will always go
334
through pycurl where possible.
337
# We don't care about checking the pycurl availability as
338
# this server will be required only when pycurl is present
340
# urls returned by this server should require the pycurl client impl
341
_url_protocol = 'http+pycurl'
added
removed
bzrlib/tests/HttpServer.py
