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
def __init__(self, path, infile):
61
:param path: File url, for error reports.
62
:param infile: File-like socket set at body start.
67
# When using multi parts response, this will be set with the headers
68
# associated with the range currently read.
70
# Default to the whole file of unspecified size
73
def set_range(self, start, size):
74
"""Change the range mapping"""
77
# Set the new _pos since that's what we want to expose
78
self._pos = self._start
80
def set_boundary(self, boundary):
81
"""Define the boundary used in a multi parts message.
83
The file should be at the beginning of the body, the first range
84
definition is read and taken into account.
86
self._boundary = boundary
87
# Decode the headers and setup the first range
89
self.read_range_definition()
91
def read_boundary(self):
92
"""Read the boundary headers defining a new range"""
93
boundary_line = '\r\n'
94
while boundary_line == '\r\n':
95
# RFC2616 19.2 Additional CRLFs may precede the first boundary
97
# To be on the safe side we allow it before any boundary line
98
boundary_line = self._file.readline()
99
if boundary_line != '--' + self._boundary + '\r\n':
100
raise errors.InvalidHttpResponse(
102
"Expected a boundary (%s) line, got '%s'" % (self._boundary,
105
def read_range_definition(self):
106
"""Read a new range definition in a multi parts message.
108
Parse the headers including the empty line following them so that we
109
are ready to read the data itself.
111
self._headers = httplib.HTTPMessage(self._file, seekable=0)
112
# Extract the range definition
113
content_range = self._headers.getheader('content-range', None)
114
if content_range is None:
115
raise errors.InvalidHttpResponse(
117
'Content-Range header missing in a multi-part response')
118
self.set_range_from_header(content_range)
120
def set_range_from_header(self, content_range):
121
"""Helper to set the new range from its description in the headers"""
123
rtype, values = content_range.split()
125
raise errors.InvalidHttpRange(self._path, content_range,
128
raise errors.InvalidHttpRange(self._path, content_range,
129
"Unsupported range type '%s'" % rtype)
131
# We don't need total, but note that it may be either the file size
132
# or '*' if the server can't or doesn't want to return the file
134
start_end, total = values.split('/')
135
start, end = start_end.split('-')
139
raise errors.InvalidHttpRange(self._path, content_range,
140
'Invalid range values')
141
size = end - start + 1
143
raise errors.InvalidHttpRange(self._path, content_range,
144
'Invalid range, size <= 0')
145
self.set_range(start, size)
147
def _checked_read(self, size):
148
"""Read the file checking for short reads"""
150
data = self._file.read(size)
152
if size > 0 and data_len != size:
153
raise errors.ShortReadvError(self._path, pos, size, data_len)
154
self._pos += data_len
157
def _seek_to_next_range(self):
158
# We will cross range boundaries
159
if self._boundary is None:
160
# If we don't have a boundary, we can't find another range
161
raise errors.InvalidRange(
162
self._path, self._pos,
163
"Range (%s, %s) exhausted"
164
% (self._start, self._size))
166
self.read_range_definition()
168
def read(self, size=-1):
169
"""Read size bytes from the current position in the file.
171
Reading across ranges is not supported. We rely on the underlying http
172
client to clean the socket if we leave bytes unread. This may occur for
173
the final boundary line of a multipart response or for any range
174
request not entirely consumed by the client (due to offset coalescing)
177
and self._pos == self._start + self._size):
181
self._seek_to_next_range()
182
elif self._pos < self._start:
183
raise errors.InvalidRange(
184
self._path, self._pos,
185
"Can't read %s bytes before range (%s, %s)"
186
% (size, self._start, self._size))
188
if size > 0 and self._pos + size > self._start + self._size:
189
raise errors.InvalidRange(
190
self._path, self._pos,
191
"Can't read %s bytes across range (%s, %s)"
192
% (size, self._start, self._size))
195
# Don't read past the range definition
196
limited = self._start + self._size - self._pos
198
limited = min(limited, size)
199
data = self._file.read(limited)
201
# Size of file unknown, the user may have specified a size or not,
202
# we delegate that to the filesocket object (-1 means read until
204
data = self._file.read(size)
205
# Update _pos respecting the data effectively read
206
self._pos += len(data)
209
def seek(self, offset, whence=0):
210
start_pos = self._pos
214
final_pos = start_pos + offset
217
final_pos = self._start + self._size + offset # offset < 0
219
raise errors.InvalidRange(
220
self._path, self._pos,
221
"RangeFile: can't seek from end while size is unknown")
223
raise ValueError("Invalid value %s for whence." % whence)
225
if final_pos < self._pos:
226
# Can't seek backwards
227
raise errors.InvalidRange(
228
self._path, self._pos,
229
'RangeFile: trying to seek backwards to %s' % final_pos)
232
cur_limit = self._start + self._size
233
while final_pos > cur_limit:
234
# We will cross range boundaries
235
remain = cur_limit - self._pos
237
# Finish reading the current range
238
self._checked_read(remain)
239
self._seek_to_next_range()
240
cur_limit = self._start + self._size
242
size = final_pos - self._pos
243
if size > 0: # size can be < 0 if we crossed a range boundary
244
# We don't need the data, just read it and throw it away
245
self._checked_read(size)
251
def handle_response(url, code, msg, data):
252
"""Interpret the code & headers and wrap the provided data in a RangeFile.
254
This is a factory method which returns an appropriate RangeFile based on
255
the code & headers it's given.
257
:param url: The url being processed. Mostly for error reporting
258
:param code: The integer HTTP response code
259
:param msg: An HTTPMessage containing the headers for the response
260
:param data: A file-like object that can be read() to get the
262
:return: A file-like object that can seek()+read() the
263
ranges indicated by the headers.
265
rfile = RangeFile(url, data)
268
size = msg.getheader('content-length', None)
273
rfile.set_range(0, size)
275
content_type = msg.getheader('content-type', None)
276
if content_type is None:
277
# When there is no content-type header we treat the response as
278
# being of type 'application/octet-stream' as per RFC2616 section
280
# Therefore it is obviously not multipart
281
content_type = 'application/octet-stream'
284
is_multipart = (msg.getmaintype() == 'multipart'
285
and msg.getsubtype() == 'byteranges')
288
# Full fledged multipart response
289
rfile.set_boundary(msg.getparam('boundary'))
291
# A response to a range request, but not multipart
292
content_range = msg.getheader('content-range', None)
293
if content_range is None:
294
raise errors.InvalidHttpResponse(url,
295
'Missing the Content-Range header in a 206 range response')
296
rfile.set_range_from_header(content_range)
298
raise errors.InvalidHttpResponse(url,
299
'Unknown response code %s' % code)
added
removed
bzrlib/transport/http/response.py
