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
17
"""Handlers for HTTP Responses.
19
The purpose of these classes is to provide a uniform interface for clients
20
to standard HTTP responses, single range responses and multipart range
25
from bisect import bisect
26
from cStringIO import StringIO
29
from bzrlib import errors
30
from bzrlib.trace import mutter
33
class ResponseRange(object):
34
"""A range in a RangeFile-object."""
36
__slots__ = ['_ent_start', '_ent_end', '_data_start']
38
def __init__(self, ent_start, ent_end, data_start):
39
self._ent_start = ent_start
40
self._ent_end = ent_end
41
self._data_start = data_start
43
def __cmp__(self, other):
44
"""Compare this to other.
46
We need this both for sorting, and so that we can
47
bisect the list of ranges.
49
if isinstance(other, int):
50
# Later on we bisect for a starting point
51
# so we allow comparing against a single integer
52
return cmp(self._ent_start, other)
54
return cmp((self._ent_start, self._ent_end, self._data_start),
55
(other._ent_start, other._ent_end, other._data_start))
58
return "%s(%s-%s,%s)" % (self.__class__.__name__,
59
self._ent_start, self._ent_end,
65
class RangeFile(object):
66
"""File-like object that allow access to partial available data.
68
Specified by a set of ranges.
71
def __init__(self, path, input_file):
76
self._data = input_file.read()
78
def _add_range(self, ent_start, ent_end, data_start):
79
"""Add an entity range.
81
:param ent_start: Start offset of entity
82
:param ent_end: End offset of entity (inclusive)
83
:param data_start: Start offset of data in data stream.
85
self._ranges.append(ResponseRange(ent_start, ent_end, data_start))
86
self._len = max(self._len, ent_end)
88
def _finish_ranges(self):
92
"""Read size bytes from the current position in the file.
94
Reading across ranges is not supported.
96
# find the last range which has a start <= pos
97
i = bisect(self._ranges, self._pos) - 1
99
if i < 0 or self._pos > self._ranges[i]._ent_end:
100
mutter('Bisect for pos: %s failed. Found offset: %d, ranges:%s',
101
self._pos, i, self._ranges)
102
raise errors.InvalidRange(self._path, self._pos)
106
# mutter('found range %s %s for pos %s', i, self._ranges[i], self._pos)
108
if (self._pos + size - 1) > r._ent_end:
109
raise errors.InvalidRange(self._path, self._pos)
111
start = r._data_start + (self._pos - r._ent_start)
113
# mutter("range read %d bytes at %d == %d-%d", size, self._pos,
115
self._pos += (end-start)
116
return self._data[start:end]
118
def seek(self, offset, whence=0):
124
self._pos = self._len + offset
126
raise ValueError("Invalid value %s for whence." % whence)
135
class HttpRangeResponse(RangeFile):
136
"""A single-range HTTP response."""
138
# TODO: jam 20060706 Consider compiling these regexes on demand
139
_CONTENT_RANGE_RE = re.compile(
140
r'\s*([^\s]+)\s+([0-9]+)-([0-9]+)/([0-9]+)\s*$')
142
def __init__(self, path, content_range, input_file):
143
# mutter("parsing 206 non-multipart response for %s", path)
144
RangeFile.__init__(self, path, input_file)
145
start, end = self._parse_range(content_range, path)
146
self._add_range(start, end, 0)
147
self._finish_ranges()
150
def _parse_range(range, path='<unknown>'):
151
"""Parse an http Content-range header and return start + end
153
:param range: The value for Content-range
154
:param path: Provide to give better error messages.
155
:return: (start, end) A tuple of integers
157
match = HttpRangeResponse._CONTENT_RANGE_RE.match(range)
159
raise errors.InvalidHttpRange(path, range,
160
"Invalid Content-range")
162
rtype, start, end, total = match.groups()
165
raise errors.InvalidHttpRange(path, range,
166
"Unsupported range type '%s'" % (rtype,))
171
except ValueError, e:
172
raise errors.InvalidHttpRange(path, range, str(e))
177
class HttpMultipartRangeResponse(RangeFile):
178
"""A multi-range HTTP response."""
180
_CONTENT_TYPE_RE = re.compile(
181
r'^\s*multipart/byteranges\s*;\s*boundary\s*=\s*("?)([^"]*?)\1\s*$')
183
# Start with --<boundary>\r\n
184
# and ignore all headers ending in \r\n
185
# except for content-range:
186
# and find the two trailing \r\n separators
187
# indicating the start of the text
188
# TODO: jam 20060706 This requires exact conformance
189
# to the spec, we probably could relax the requirement
190
# of \r\n, and use something more like (\r?\n)
192
"^--%s(?:\r\n(?:(?:content-range:([^\r]+))|[^\r]+))+\r\n\r\n")
194
def __init__(self, path, content_type, input_file):
195
# mutter("parsing 206 multipart response for %s", path)
196
# TODO: jam 20060706 Is it valid to initialize a
197
# grandparent without initializing parent?
198
RangeFile.__init__(self, path, input_file)
200
self.boundary_regex = self._parse_boundary(content_type, path)
201
# mutter('response:\n%r', self._data)
203
for match in self.boundary_regex.finditer(self._data):
204
ent_start, ent_end = HttpRangeResponse._parse_range(match.group(1),
206
self._add_range(ent_start, ent_end, match.end())
208
self._finish_ranges()
211
def _parse_boundary(ctype, path='<unknown>'):
212
"""Parse the Content-type field.
214
This expects a multipart Content-type, and returns a
215
regex which is capable of finding the boundaries
216
in the multipart data.
218
match = HttpMultipartRangeResponse._CONTENT_TYPE_RE.match(ctype)
220
raise errors.InvalidHttpContentType(path, ctype,
221
"Expected multipart/byteranges with boundary")
223
boundary = match.group(2)
224
# mutter('multipart boundary is %s', boundary)
225
pattern = HttpMultipartRangeResponse._BOUNDARY_PATT
226
return re.compile(pattern % re.escape(boundary),
227
re.IGNORECASE | re.MULTILINE)
230
def _is_multipart(content_type):
231
return content_type.startswith('multipart/byteranges;')
234
def handle_response(url, code, headers, data):
235
"""Interpret the code & headers and return a HTTP response.
237
This is a factory method which returns an appropriate HTTP response
238
based on the code & headers it's given.
240
:param url: The url being processed. Mostly for error reporting
241
:param code: The integer HTTP response code
242
:param headers: A dict-like object that contains the HTTP response headers
243
:param data: A file-like object that can be read() to get the
245
:return: A file-like object that can seek()+read() the
246
ranges indicated by the headers.
251
content_type = headers['Content-Type']
253
# When there is no content-type header we treat
254
# the response as being of type 'application/octet-stream' as per
255
# RFC2616 section 7.2.1.
256
# Therefore it is obviously not multipart
257
content_type = 'application/octet-stream'
260
is_multipart = _is_multipart(content_type)
263
# Full fledged multipart response
264
return HttpMultipartRangeResponse(url, content_type, data)
266
# A response to a range request, but not multipart
268
content_range = headers['Content-Range']
270
raise errors.InvalidHttpResponse(url,
271
'Missing the Content-Range header in a 206 range response')
272
return HttpRangeResponse(url, content_range, data)
274
# A regular non-range response, unfortunately the result from
275
# urllib doesn't support seek, so we wrap it in a StringIO
276
tell = getattr(data, 'tell', None)
278
return StringIO(data.read())
281
raise errors.NoSuchFile(url)
283
# We don't know which, but one of the ranges we specified
284
# was wrong. So we raise with 0 for a lack of a better
286
raise errors.InvalidRange(url,0)
288
# TODO: jam 20060713 Properly handle redirects (302 Found, etc)
289
# The '_get' code says to follow redirects, we probably
290
# should actually handle the return values
292
raise errors.InvalidHttpResponse(url, "Unknown response code %s"
added
removed
bzrlib/transport/http/response.py
