/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 breezy/transport/http/response.py

  • Committer: Jelmer Vernooij
  • Date: 2017-06-08 00:00:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6672.
  • Revision ID: jelmer@jelmer.uk-20170608000028-e3ggtt4wjbcjh91j
Drop pycurl support.

Show diffs side-by-side

added added

removed removed

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