/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/transport/http/response.py

  • Committer: Jelmer Vernooij
  • Date: 2012-04-01 23:35:52 UTC
  • mto: This revision was merged to the branch mainline in revision 6518.
  • Revision ID: jelmer@samba.org-20120401233552-ovkuloera0dcz5gb
Fix some paths, thanks Marius.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/http/response.py
 
1
# Copyright (C) 2006-2011 Canonical Ltd
 
2
#
 
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.
 
7
#
 
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.
 
12
#
 
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""Handlers for HTTP Responses.
 
18
 
 
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
 
21
responses.
 
22
"""
 
23
 
 
24
from __future__ import absolute_import
 
25
 
 
26
import os
 
27
import httplib
 
28
from cStringIO import StringIO
 
29
import rfc822
 
30
 
 
31
from bzrlib import (
 
32
    errors,
 
33
    osutils,
 
34
    )
 
35
 
 
36
 
 
37
class ResponseFile(object):
 
38
    """A wrapper around the http socket containing the result of a GET request.
 
39
 
 
40
    Only read() and seek() (forward) are supported.
 
41
    """
 
42
    def __init__(self, path, infile):
 
43
        """Constructor.
 
44
 
 
45
        :param path: File url, for error reports.
 
46
 
 
47
        :param infile: File-like socket set at body start.
 
48
        """
 
49
        self._path = path
 
50
        self._file = infile
 
51
        self._pos = 0
 
52
 
 
53
    def close(self):
 
54
        """Close this file.
 
55
 
 
56
        Dummy implementation for consistency with the 'file' API.
 
57
        """
 
58
 
 
59
    def read(self, size=-1):
 
60
        """Read size bytes from the current position in the file.
 
61
 
 
62
        :param size:  The number of bytes to read.  Leave unspecified or pass
 
63
            -1 to read to EOF.
 
64
        """
 
65
        data =  self._file.read(size)
 
66
        self._pos += len(data)
 
67
        return data
 
68
 
 
69
    def seek(self, offset, whence=os.SEEK_SET):
 
70
        if whence == os.SEEK_SET:
 
71
            if offset < self._pos:
 
72
                raise AsserttionError(
 
73
                    "Can't seek backwards, pos: %s, offset: %s"
 
74
                    % (self._pos, offfset))
 
75
            to_discard = offset - self._pos
 
76
        elif whence == os.SEEK_CUR:
 
77
            to_discard = offset
 
78
        else:
 
79
            raise AssertionError("Can't seek backwards")
 
80
        if to_discard:
 
81
            # Just discard the unwanted bytes
 
82
            self.read(to_discard)
 
83
 
 
84
# A RangeFile expects the following grammar (simplified to outline the
 
85
# assumptions we rely upon).
 
86
 
 
87
# file: single_range
 
88
#     | multiple_range
 
89
 
 
90
# single_range: content_range_header data
 
91
 
 
92
# multiple_range: boundary_header boundary (content_range_header data boundary)+
 
93
 
 
94
class RangeFile(ResponseFile):
 
95
    """File-like object that allow access to partial available data.
 
96
 
 
97
    All accesses should happen sequentially since the acquisition occurs during
 
98
    an http response reception (as sockets can't be seeked, we simulate the
 
99
    seek by just reading and discarding the data).
 
100
 
 
101
    The access pattern is defined by a set of ranges discovered as reading
 
102
    progress. Only one range is available at a given time, so all accesses
 
103
    should happen with monotonically increasing offsets.
 
104
    """
 
105
 
 
106
    # in _checked_read() below, we may have to discard several MB in the worst
 
107
    # case. To avoid buffering that much, we read and discard by chunks
 
108
    # instead. The underlying file is either a socket or a StringIO, so reading
 
109
    # 8k chunks should be fine.
 
110
    _discarded_buf_size = 8192
 
111
 
 
112
    # maximum size of read requests -- used to avoid MemoryError issues in recv
 
113
    _max_read_size = 512 * 1024
 
114
 
 
115
    def __init__(self, path, infile):
 
116
        """Constructor.
 
117
 
 
118
        :param path: File url, for error reports.
 
119
 
 
120
        :param infile: File-like socket set at body start.
 
121
        """
 
122
        super(RangeFile, self).__init__(path, infile)
 
123
        self._boundary = None
 
124
        # When using multi parts response, this will be set with the headers
 
125
        # associated with the range currently read.
 
126
        self._headers = None
 
127
        # Default to the whole file of unspecified size
 
128
        self.set_range(0, -1)
 
129
 
 
130
    def set_range(self, start, size):
 
131
        """Change the range mapping"""
 
132
        self._start = start
 
133
        self._size = size
 
134
        # Set the new _pos since that's what we want to expose
 
135
        self._pos = self._start
 
136
 
 
137
    def set_boundary(self, boundary):
 
138
        """Define the boundary used in a multi parts message.
 
139
 
 
140
        The file should be at the beginning of the body, the first range
 
141
        definition is read and taken into account.
 
142
        """
 
143
        self._boundary = boundary
 
144
        # Decode the headers and setup the first range
 
145
        self.read_boundary()
 
146
        self.read_range_definition()
 
147
 
 
148
    def read_boundary(self):
 
149
        """Read the boundary headers defining a new range"""
 
150
        boundary_line = '\r\n'
 
151
        while boundary_line == '\r\n':
 
152
            # RFC2616 19.2 Additional CRLFs may precede the first boundary
 
153
            # string entity.
 
154
            # To be on the safe side we allow it before any boundary line
 
155
            boundary_line = self._file.readline()
 
156
 
 
157
        if boundary_line == '':
 
158
            # A timeout in the proxy server caused the response to end early.
 
159
            # See launchpad bug 198646.
 
160
            raise errors.HttpBoundaryMissing(
 
161
                self._path,
 
162
                self._boundary)
 
163
 
 
164
        if boundary_line != '--' + self._boundary + '\r\n':
 
165
            # rfc822.unquote() incorrectly unquotes strings enclosed in <>
 
166
            # IIS 6 and 7 incorrectly wrap boundary strings in <>
 
167
            # together they make a beautiful bug, which we will be gracious
 
168
            # about here
 
169
            if (self._unquote_boundary(boundary_line) !=
 
170
                '--' + self._boundary + '\r\n'):
 
171
                raise errors.InvalidHttpResponse(
 
172
                    self._path,
 
173
                    "Expected a boundary (%s) line, got '%s'"
 
174
                    % (self._boundary, boundary_line))
 
175
 
 
176
    def _unquote_boundary(self, b):
 
177
        return b[:2] + rfc822.unquote(b[2:-2]) + b[-2:]
 
178
 
 
179
    def read_range_definition(self):
 
180
        """Read a new range definition in a multi parts message.
 
181
 
 
182
        Parse the headers including the empty line following them so that we
 
183
        are ready to read the data itself.
 
184
        """
 
185
        self._headers = httplib.HTTPMessage(self._file, seekable=0)
 
186
        # Extract the range definition
 
187
        content_range = self._headers.getheader('content-range', None)
 
188
        if content_range is None:
 
189
            raise errors.InvalidHttpResponse(
 
190
                self._path,
 
191
                'Content-Range header missing in a multi-part response')
 
192
        self.set_range_from_header(content_range)
 
193
 
 
194
    def set_range_from_header(self, content_range):
 
195
        """Helper to set the new range from its description in the headers"""
 
196
        try:
 
197
            rtype, values = content_range.split()
 
198
        except ValueError:
 
199
            raise errors.InvalidHttpRange(self._path, content_range,
 
200
                                          'Malformed header')
 
201
        if rtype != 'bytes':
 
202
            raise errors.InvalidHttpRange(self._path, content_range,
 
203
                                          "Unsupported range type '%s'" % rtype)
 
204
        try:
 
205
            # We don't need total, but note that it may be either the file size
 
206
            # or '*' if the server can't or doesn't want to return the file
 
207
            # size.
 
208
            start_end, total = values.split('/')
 
209
            start, end = start_end.split('-')
 
210
            start = int(start)
 
211
            end = int(end)
 
212
        except ValueError:
 
213
            raise errors.InvalidHttpRange(self._path, content_range,
 
214
                                          'Invalid range values')
 
215
        size = end - start + 1
 
216
        if size <= 0:
 
217
            raise errors.InvalidHttpRange(self._path, content_range,
 
218
                                          'Invalid range, size <= 0')
 
219
        self.set_range(start, size)
 
220
 
 
221
    def _checked_read(self, size):
 
222
        """Read the file checking for short reads.
 
223
 
 
224
        The data read is discarded along the way.
 
225
        """
 
226
        pos = self._pos
 
227
        remaining = size
 
228
        while remaining > 0:
 
229
            data = self._file.read(min(remaining, self._discarded_buf_size))
 
230
            remaining -= len(data)
 
231
            if not data:
 
232
                raise errors.ShortReadvError(self._path, pos, size,
 
233
                                             size - remaining)
 
234
        self._pos += size
 
235
 
 
236
    def _seek_to_next_range(self):
 
237
        # We will cross range boundaries
 
238
        if self._boundary is None:
 
239
            # If we don't have a boundary, we can't find another range
 
240
            raise errors.InvalidRange(self._path, self._pos,
 
241
                                      "Range (%s, %s) exhausted"
 
242
                                      % (self._start, self._size))
 
243
        self.read_boundary()
 
244
        self.read_range_definition()
 
245
 
 
246
    def read(self, size=-1):
 
247
        """Read size bytes from the current position in the file.
 
248
 
 
249
        Reading across ranges is not supported. We rely on the underlying http
 
250
        client to clean the socket if we leave bytes unread. This may occur for
 
251
        the final boundary line of a multipart response or for any range
 
252
        request not entirely consumed by the client (due to offset coalescing)
 
253
 
 
254
        :param size:  The number of bytes to read.  Leave unspecified or pass
 
255
            -1 to read to EOF.
 
256
        """
 
257
        if (self._size > 0
 
258
            and self._pos == self._start + self._size):
 
259
            if size == 0:
 
260
                return ''
 
261
            else:
 
262
                self._seek_to_next_range()
 
263
        elif self._pos < self._start:
 
264
            raise errors.InvalidRange(
 
265
                self._path, self._pos,
 
266
                "Can't read %s bytes before range (%s, %s)"
 
267
                % (size, self._start, self._size))
 
268
        if self._size > 0:
 
269
            if size > 0 and self._pos + size > self._start + self._size:
 
270
                raise errors.InvalidRange(
 
271
                    self._path, self._pos,
 
272
                    "Can't read %s bytes across range (%s, %s)"
 
273
                    % (size, self._start, self._size))
 
274
 
 
275
        # read data from file
 
276
        buffer = StringIO()
 
277
        limited = size
 
278
        if self._size > 0:
 
279
            # Don't read past the range definition
 
280
            limited = self._start + self._size - self._pos
 
281
            if size >= 0:
 
282
                limited = min(limited, size)
 
283
        osutils.pumpfile(self._file, buffer, limited, self._max_read_size)
 
284
        data = buffer.getvalue()
 
285
 
 
286
        # Update _pos respecting the data effectively read
 
287
        self._pos += len(data)
 
288
        return data
 
289
 
 
290
    def seek(self, offset, whence=0):
 
291
        start_pos = self._pos
 
292
        if whence == 0:
 
293
            final_pos = offset
 
294
        elif whence == 1:
 
295
            final_pos = start_pos + offset
 
296
        elif whence == 2:
 
297
            if self._size > 0:
 
298
                final_pos = self._start + self._size + offset # offset < 0
 
299
            else:
 
300
                raise errors.InvalidRange(
 
301
                    self._path, self._pos,
 
302
                    "RangeFile: can't seek from end while size is unknown")
 
303
        else:
 
304
            raise ValueError("Invalid value %s for whence." % whence)
 
305
 
 
306
        if final_pos < self._pos:
 
307
            # Can't seek backwards
 
308
            raise errors.InvalidRange(
 
309
                self._path, self._pos,
 
310
                'RangeFile: trying to seek backwards to %s' % final_pos)
 
311
 
 
312
        if self._size > 0:
 
313
            cur_limit = self._start + self._size
 
314
            while final_pos > cur_limit:
 
315
                # We will cross range boundaries
 
316
                remain = cur_limit - self._pos
 
317
                if remain > 0:
 
318
                    # Finish reading the current range
 
319
                    self._checked_read(remain)
 
320
                self._seek_to_next_range()
 
321
                cur_limit = self._start + self._size
 
322
 
 
323
        size = final_pos - self._pos
 
324
        if size > 0: # size can be < 0 if we crossed a range boundary
 
325
            # We don't need the data, just read it and throw it away
 
326
            self._checked_read(size)
 
327
 
 
328
    def tell(self):
 
329
        return self._pos
 
330
 
 
331
 
 
332
def handle_response(url, code, msg, data):
 
333
    """Interpret the code & headers and wrap the provided data in a RangeFile.
 
334
 
 
335
    This is a factory method which returns an appropriate RangeFile based on
 
336
    the code & headers it's given.
 
337
 
 
338
    :param url: The url being processed. Mostly for error reporting
 
339
    :param code: The integer HTTP response code
 
340
    :param msg: An HTTPMessage containing the headers for the response
 
341
    :param data: A file-like object that can be read() to get the
 
342
                 requested data
 
343
    :return: A file-like object that can seek()+read() the
 
344
             ranges indicated by the headers.
 
345
    """
 
346
    if code == 200:
 
347
        # A whole file
 
348
        rfile = ResponseFile(url, data)
 
349
    elif code == 206:
 
350
        rfile = RangeFile(url, data)
 
351
        content_type = msg.getheader('content-type', None)
 
352
        if content_type is None:
 
353
            # When there is no content-type header we treat the response as
 
354
            # being of type 'application/octet-stream' as per RFC2616 section
 
355
            # 7.2.1.
 
356
            # Therefore it is obviously not multipart
 
357
            content_type = 'application/octet-stream'
 
358
            is_multipart = False
 
359
        else:
 
360
            is_multipart = (msg.getmaintype() == 'multipart'
 
361
                            and msg.getsubtype() == 'byteranges')
 
362
 
 
363
        if is_multipart:
 
364
            # Full fledged multipart response
 
365
            rfile.set_boundary(msg.getparam('boundary'))
 
366
        else:
 
367
            # A response to a range request, but not multipart
 
368
            content_range = msg.getheader('content-range', None)
 
369
            if content_range is None:
 
370
                raise errors.InvalidHttpResponse(url,
 
371
                    'Missing the Content-Range header in a 206 range response')
 
372
            rfile.set_range_from_header(content_range)
 
373
    else:
 
374
        raise errors.InvalidHttpResponse(url,
 
375
                                         'Unknown response code %s' % code)
 
376
 
 
377
    return rfile
 
378