1
# Copyright (C) 2006, 2007 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
33
# A RangeFile expects the following grammar (simplified to outline the
34
# assumptions we rely upon).
40
# whole_file: [content_length_header] data
42
# single_range: content_range_header data
44
# multiple_range: boundary_header boundary (content_range_header data boundary)+
46
class RangeFile(object):
47
"""File-like object that allow access to partial available data.
49
All accesses should happen sequentially since the acquisition occurs during
50
an http response reception (as sockets can't be seeked, we simulate the
51
seek by just reading and discarding the data).
53
The access pattern is defined by a set of ranges discovered as reading
54
progress. Only one range is available at a given time, so all accesses
55
should happen with monotonically increasing offsets.
58
# in _checked_read() below, we may have to discard several MB in the worst
59
# case. To avoid buffering that much, we read and discard by chunks
60
# instead. The underlying file is either a socket or a StringIO, so reading
61
# 8k chunks should be fine.
62
_discarded_buf_size = 8192
64
def __init__(self, path, infile):
67
:param path: File url, for error reports.
68
:param infile: File-like socket set at body start.
73
# When using multi parts response, this will be set with the headers
74
# associated with the range currently read.
76
# Default to the whole file of unspecified size
79
def set_range(self, start, size):
80
"""Change the range mapping"""
83
# Set the new _pos since that's what we want to expose
84
self._pos = self._start
86
def set_boundary(self, boundary):
87
"""Define the boundary used in a multi parts message.
89
The file should be at the beginning of the body, the first range
90
definition is read and taken into account.
92
self._boundary = boundary
93
# Decode the headers and setup the first range
95
self.read_range_definition()
97
def read_boundary(self):
98
"""Read the boundary headers defining a new range"""
99
boundary_line = '\r\n'
100
while boundary_line == '\r\n':
101
# RFC2616 19.2 Additional CRLFs may precede the first boundary
103
# To be on the safe side we allow it before any boundary line
104
boundary_line = self._file.readline()
105
if boundary_line != '--' + self._boundary + '\r\n':
106
raise errors.InvalidHttpResponse(
108
"Expected a boundary (%s) line, got '%s'" % (self._boundary,
111
def read_range_definition(self):
112
"""Read a new range definition in a multi parts message.
114
Parse the headers including the empty line following them so that we
115
are ready to read the data itself.
117
self._headers = httplib.HTTPMessage(self._file, seekable=0)
118
# Extract the range definition
119
content_range = self._headers.getheader('content-range', None)
120
if content_range is None:
121
raise errors.InvalidHttpResponse(
123
'Content-Range header missing in a multi-part response')
124
self.set_range_from_header(content_range)
126
def set_range_from_header(self, content_range):
127
"""Helper to set the new range from its description in the headers"""
129
rtype, values = content_range.split()
131
raise errors.InvalidHttpRange(self._path, content_range,
134
raise errors.InvalidHttpRange(self._path, content_range,
135
"Unsupported range type '%s'" % rtype)
137
# We don't need total, but note that it may be either the file size
138
# or '*' if the server can't or doesn't want to return the file
140
start_end, total = values.split('/')
141
start, end = start_end.split('-')
145
raise errors.InvalidHttpRange(self._path, content_range,
146
'Invalid range values')
147
size = end - start + 1
149
raise errors.InvalidHttpRange(self._path, content_range,
150
'Invalid range, size <= 0')
151
self.set_range(start, size)
153
def _checked_read(self, size):
154
"""Read the file checking for short reads.
156
The data read is discarded along the way.
161
data = self._file.read(min(remaining, self._discarded_buf_size))
162
remaining -= len(data)
164
raise errors.ShortReadvError(self._path, pos, size,
168
def _seek_to_next_range(self):
169
# We will cross range boundaries
170
if self._boundary is None:
171
# If we don't have a boundary, we can't find another range
172
raise errors.InvalidRange(self._path, self._pos,
173
"Range (%s, %s) exhausted"
174
% (self._start, self._size))
176
self.read_range_definition()
178
def read(self, size=-1):
179
"""Read size bytes from the current position in the file.
181
Reading across ranges is not supported. We rely on the underlying http
182
client to clean the socket if we leave bytes unread. This may occur for
183
the final boundary line of a multipart response or for any range
184
request not entirely consumed by the client (due to offset coalescing)
187
and self._pos == self._start + self._size):
191
self._seek_to_next_range()
192
elif self._pos < self._start:
193
raise errors.InvalidRange(
194
self._path, self._pos,
195
"Can't read %s bytes before range (%s, %s)"
196
% (size, self._start, self._size))
198
if size > 0 and self._pos + size > self._start + self._size:
199
raise errors.InvalidRange(
200
self._path, self._pos,
201
"Can't read %s bytes across range (%s, %s)"
202
% (size, self._start, self._size))
205
# Don't read past the range definition
206
limited = self._start + self._size - self._pos
208
limited = min(limited, size)
209
data = self._file.read(limited)
211
# Size of file unknown, the user may have specified a size or not,
212
# we delegate that to the filesocket object (-1 means read until
214
data = self._file.read(size)
215
# Update _pos respecting the data effectively read
216
self._pos += len(data)
219
def seek(self, offset, whence=0):
220
start_pos = self._pos
224
final_pos = start_pos + offset
227
final_pos = self._start + self._size + offset # offset < 0
229
raise errors.InvalidRange(
230
self._path, self._pos,
231
"RangeFile: can't seek from end while size is unknown")
233
raise ValueError("Invalid value %s for whence." % whence)
235
if final_pos < self._pos:
236
# Can't seek backwards
237
raise errors.InvalidRange(
238
self._path, self._pos,
239
'RangeFile: trying to seek backwards to %s' % final_pos)
242
cur_limit = self._start + self._size
243
while final_pos > cur_limit:
244
# We will cross range boundaries
245
remain = cur_limit - self._pos
247
# Finish reading the current range
248
self._checked_read(remain)
249
self._seek_to_next_range()
250
cur_limit = self._start + self._size
252
size = final_pos - self._pos
253
if size > 0: # size can be < 0 if we crossed a range boundary
254
# We don't need the data, just read it and throw it away
255
self._checked_read(size)
261
def handle_response(url, code, msg, data):
262
"""Interpret the code & headers and wrap the provided data in a RangeFile.
264
This is a factory method which returns an appropriate RangeFile based on
265
the code & headers it's given.
267
:param url: The url being processed. Mostly for error reporting
268
:param code: The integer HTTP response code
269
:param msg: An HTTPMessage containing the headers for the response
270
:param data: A file-like object that can be read() to get the
272
:return: A file-like object that can seek()+read() the
273
ranges indicated by the headers.
275
rfile = RangeFile(url, data)
278
size = msg.getheader('content-length', None)
283
rfile.set_range(0, size)
285
content_type = msg.getheader('content-type', None)
286
if content_type is None:
287
# When there is no content-type header we treat the response as
288
# being of type 'application/octet-stream' as per RFC2616 section
290
# Therefore it is obviously not multipart
291
content_type = 'application/octet-stream'
294
is_multipart = (msg.getmaintype() == 'multipart'
295
and msg.getsubtype() == 'byteranges')
298
# Full fledged multipart response
299
rfile.set_boundary(msg.getparam('boundary'))
301
# A response to a range request, but not multipart
302
content_range = msg.getheader('content-range', None)
303
if content_range is None:
304
raise errors.InvalidHttpResponse(url,
305
'Missing the Content-Range header in a 206 range response')
306
rfile.set_range_from_header(content_range)
308
raise errors.InvalidHttpResponse(url,
309
'Unknown response code %s' % code)
added
removed
bzrlib/transport/http/response.py
