/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: Gustav Hartvigsson
  • Date: 2021-01-09 21:36:27 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20210109213627-h1xwcutzy9m7a99b
Added 'Case Preserving Working Tree Use Cases' from Canonical Wiki

* Addod a page from the Canonical Bazaar wiki
  with information on the scmeatics of case
  perserving filesystems an a case insensitive
  filesystem works.
  
  * Needs re-work, but this will do as it is the
    same inforamoton as what was on the linked
    page in the currint documentation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/transport/http/response.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
21
21
responses.
22
22
"""
23
23
 
24
 
 
25
 
import httplib
26
 
from cStringIO import StringIO
27
 
import rfc822
28
 
 
29
 
from bzrlib import (
 
24
import cgi
 
25
from io import BytesIO
 
26
import os
 
27
import http.client as http_client
 
28
import email.utils as email_utils
 
29
 
 
30
from ... import (
30
31
    errors,
31
 
    trace,
32
32
    osutils,
33
33
    )
34
34
 
35
35
 
 
36
class ResponseFile(object):
 
37
    """A wrapper around the http socket containing the result of a GET request.
 
38
 
 
39
    Only read() and seek() (forward) are supported.
 
40
 
 
41
    """
 
42
 
 
43
    def __init__(self, path, infile):
 
44
        """Constructor.
 
45
 
 
46
        :param path: File url, for error reports.
 
47
 
 
48
        :param infile: File-like socket set at body start.
 
49
        """
 
50
        self._path = path
 
51
        self._file = infile
 
52
        self._pos = 0
 
53
 
 
54
    def close(self):
 
55
        """Close this file.
 
56
 
 
57
        Dummy implementation for consistency with the 'file' API.
 
58
        """
 
59
 
 
60
    def __enter__(self):
 
61
        return self
 
62
 
 
63
    def __exit__(self, exc_type, exc_val, exc_tb):
 
64
        return False  # propogate exceptions.
 
65
 
 
66
    def read(self, size=None):
 
67
        """Read size bytes from the current position in the file.
 
68
 
 
69
        :param size:  The number of bytes to read.  Leave unspecified or pass
 
70
            -1 to read to EOF.
 
71
        """
 
72
        data = self._file.read(size)
 
73
        self._pos += len(data)
 
74
        return data
 
75
 
 
76
    def readline(self):
 
77
        data = self._file.readline()
 
78
        self._pos += len(data)
 
79
        return data
 
80
 
 
81
    def readlines(self, size=None):
 
82
        data = self._file.readlines()
 
83
        self._pos += sum(map(len, data))
 
84
        return data
 
85
 
 
86
    def __iter__(self):
 
87
        while True:
 
88
            line = self.readline()
 
89
            if not line:
 
90
                return
 
91
            yield line
 
92
 
 
93
    def tell(self):
 
94
        return self._pos
 
95
 
 
96
    def seek(self, offset, whence=os.SEEK_SET):
 
97
        if whence == os.SEEK_SET:
 
98
            if offset < self._pos:
 
99
                raise AssertionError(
 
100
                    "Can't seek backwards, pos: %s, offset: %s"
 
101
                    % (self._pos, offset))
 
102
            to_discard = offset - self._pos
 
103
        elif whence == os.SEEK_CUR:
 
104
            to_discard = offset
 
105
        else:
 
106
            raise AssertionError("Can't seek backwards")
 
107
        if to_discard:
 
108
            # Just discard the unwanted bytes
 
109
            self.read(to_discard)
 
110
 
36
111
# A RangeFile expects the following grammar (simplified to outline the
37
112
# assumptions we rely upon).
38
113
 
39
 
# file: whole_file
40
 
#     | single_range
 
114
# file: single_range
41
115
#     | multiple_range
42
116
 
43
 
# whole_file: [content_length_header] data
44
 
 
45
117
# single_range: content_range_header data
46
118
 
47
119
# multiple_range: boundary_header boundary (content_range_header data boundary)+
48
120
 
49
 
class RangeFile(object):
 
121
 
 
122
class RangeFile(ResponseFile):
50
123
    """File-like object that allow access to partial available data.
51
124
 
52
125
    All accesses should happen sequentially since the acquisition occurs during
60
133
 
61
134
    # in _checked_read() below, we may have to discard several MB in the worst
62
135
    # case. To avoid buffering that much, we read and discard by chunks
63
 
    # instead. The underlying file is either a socket or a StringIO, so reading
 
136
    # instead. The underlying file is either a socket or a BytesIO, so reading
64
137
    # 8k chunks should be fine.
65
138
    _discarded_buf_size = 8192
66
139
 
71
144
        """Constructor.
72
145
 
73
146
        :param path: File url, for error reports.
 
147
 
74
148
        :param infile: File-like socket set at body start.
75
149
        """
76
 
        self._path = path
77
 
        self._file = infile
 
150
        super(RangeFile, self).__init__(path, infile)
78
151
        self._boundary = None
79
152
        # When using multi parts response, this will be set with the headers
80
153
        # associated with the range currently read.
95
168
        The file should be at the beginning of the body, the first range
96
169
        definition is read and taken into account.
97
170
        """
 
171
        if not isinstance(boundary, bytes):
 
172
            raise TypeError(boundary)
98
173
        self._boundary = boundary
99
174
        # Decode the headers and setup the first range
100
175
        self.read_boundary()
102
177
 
103
178
    def read_boundary(self):
104
179
        """Read the boundary headers defining a new range"""
105
 
        boundary_line = '\r\n'
106
 
        while boundary_line == '\r\n':
 
180
        boundary_line = b'\r\n'
 
181
        while boundary_line == b'\r\n':
107
182
            # RFC2616 19.2 Additional CRLFs may precede the first boundary
108
183
            # string entity.
109
184
            # To be on the safe side we allow it before any boundary line
110
185
            boundary_line = self._file.readline()
111
186
 
112
 
        if boundary_line != '--' + self._boundary + '\r\n':
113
 
            # rfc822.unquote() incorrectly unquotes strings enclosed in <>
 
187
        if boundary_line == b'':
 
188
            # A timeout in the proxy server caused the response to end early.
 
189
            # See launchpad bug 198646.
 
190
            raise errors.HttpBoundaryMissing(
 
191
                self._path,
 
192
                self._boundary)
 
193
 
 
194
        if boundary_line != b'--' + self._boundary + b'\r\n':
 
195
            # email_utils.unquote() incorrectly unquotes strings enclosed in <>
114
196
            # IIS 6 and 7 incorrectly wrap boundary strings in <>
115
197
            # together they make a beautiful bug, which we will be gracious
116
198
            # about here
117
199
            if (self._unquote_boundary(boundary_line) !=
118
 
                '--' + self._boundary + '\r\n'):
 
200
                    b'--' + self._boundary + b'\r\n'):
119
201
                raise errors.InvalidHttpResponse(
120
202
                    self._path,
121
203
                    "Expected a boundary (%s) line, got '%s'"
122
204
                    % (self._boundary, boundary_line))
123
205
 
124
206
    def _unquote_boundary(self, b):
125
 
        return b[:2] + rfc822.unquote(b[2:-2]) + b[-2:]
 
207
        return b[:2] + email_utils.unquote(b[2:-2].decode('ascii')).encode('ascii') + b[-2:]
126
208
 
127
209
    def read_range_definition(self):
128
210
        """Read a new range definition in a multi parts message.
130
212
        Parse the headers including the empty line following them so that we
131
213
        are ready to read the data itself.
132
214
        """
133
 
        self._headers = httplib.HTTPMessage(self._file, seekable=0)
 
215
        self._headers = http_client.parse_headers(self._file)
134
216
        # Extract the range definition
135
 
        content_range = self._headers.getheader('content-range', None)
 
217
        content_range = self._headers.get('content-range', None)
136
218
        if content_range is None:
137
219
            raise errors.InvalidHttpResponse(
138
220
                self._path,
203
285
            -1 to read to EOF.
204
286
        """
205
287
        if (self._size > 0
206
 
            and self._pos == self._start + self._size):
 
288
                and self._pos == self._start + self._size):
207
289
            if size == 0:
208
 
                return ''
 
290
                return b''
209
291
            else:
210
292
                self._seek_to_next_range()
211
293
        elif self._pos < self._start:
221
303
                    % (size, self._start, self._size))
222
304
 
223
305
        # read data from file
224
 
        buffer = StringIO()
 
306
        buf = BytesIO()
225
307
        limited = size
226
308
        if self._size > 0:
227
309
            # Don't read past the range definition
228
310
            limited = self._start + self._size - self._pos
229
311
            if size >= 0:
230
312
                limited = min(limited, size)
231
 
        osutils.pumpfile(self._file, buffer, limited, self._max_read_size)
232
 
        data = buffer.getvalue()
 
313
        osutils.pumpfile(self._file, buf, limited, self._max_read_size)
 
314
        data = buf.getvalue()
233
315
 
234
316
        # Update _pos respecting the data effectively read
235
317
        self._pos += len(data)
243
325
            final_pos = start_pos + offset
244
326
        elif whence == 2:
245
327
            if self._size > 0:
246
 
                final_pos = self._start + self._size + offset # offset < 0
 
328
                final_pos = self._start + self._size + offset  # offset < 0
247
329
            else:
248
330
                raise errors.InvalidRange(
249
331
                    self._path, self._pos,
269
351
                cur_limit = self._start + self._size
270
352
 
271
353
        size = final_pos - self._pos
272
 
        if size > 0: # size can be < 0 if we crossed a range boundary
 
354
        if size > 0:  # size can be < 0 if we crossed a range boundary
273
355
            # We don't need the data, just read it and throw it away
274
356
            self._checked_read(size)
275
357
 
277
359
        return self._pos
278
360
 
279
361
 
280
 
def handle_response(url, code, msg, data):
 
362
def handle_response(url, code, getheader, data):
281
363
    """Interpret the code & headers and wrap the provided data in a RangeFile.
282
364
 
283
365
    This is a factory method which returns an appropriate RangeFile based on
285
367
 
286
368
    :param url: The url being processed. Mostly for error reporting
287
369
    :param code: The integer HTTP response code
288
 
    :param msg: An HTTPMessage containing the headers for the response
 
370
    :param getheader: Function for retrieving header
289
371
    :param data: A file-like object that can be read() to get the
290
372
                 requested data
291
373
    :return: A file-like object that can seek()+read() the
292
374
             ranges indicated by the headers.
293
375
    """
294
 
    rfile = RangeFile(url, data)
295
376
    if code == 200:
296
377
        # A whole file
297
 
        size = msg.getheader('content-length', None)
298
 
        if size is None:
299
 
            size = -1
300
 
        else:
301
 
            size = int(size)
302
 
        rfile.set_range(0, size)
 
378
        rfile = ResponseFile(url, data)
303
379
    elif code == 206:
304
 
        content_type = msg.getheader('content-type', None)
305
 
        if content_type is None:
306
 
            # When there is no content-type header we treat the response as
307
 
            # being of type 'application/octet-stream' as per RFC2616 section
308
 
            # 7.2.1.
309
 
            # Therefore it is obviously not multipart
310
 
            content_type = 'application/octet-stream'
311
 
            is_multipart = False
312
 
        else:
313
 
            is_multipart = (msg.getmaintype() == 'multipart'
314
 
                            and msg.getsubtype() == 'byteranges')
315
 
 
316
 
        if is_multipart:
317
 
            # Full fledged multipart response
318
 
            rfile.set_boundary(msg.getparam('boundary'))
 
380
        rfile = RangeFile(url, data)
 
381
        # When there is no content-type header we treat the response as
 
382
        # being of type 'application/octet-stream' as per RFC2616 section
 
383
        # 7.2.1.
 
384
        # Therefore it is obviously not multipart
 
385
        content_type = getheader('content-type', 'application/octet-stream')
 
386
        mimetype, options = cgi.parse_header(content_type)
 
387
        if mimetype == 'multipart/byteranges':
 
388
            rfile.set_boundary(options['boundary'].encode('ascii'))
319
389
        else:
320
390
            # A response to a range request, but not multipart
321
 
            content_range = msg.getheader('content-range', None)
 
391
            content_range = getheader('content-range', None)
322
392
            if content_range is None:
323
 
                raise errors.InvalidHttpResponse(url,
324
 
                    'Missing the Content-Range header in a 206 range response')
 
393
                raise errors.InvalidHttpResponse(
 
394
                    url, 'Missing the Content-Range header in a 206 range response')
325
395
            rfile.set_range_from_header(content_range)
326
396
    else:
327
 
        raise errors.InvalidHttpResponse(url,
328
 
                                         'Unknown response code %s' % code)
 
397
        raise errors.UnexpectedHttpStatus(url, code)
329
398
 
330
399
    return rfile
331