/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/tests/http_server.py

  • Committer: Jelmer Vernooij
  • Date: 2018-07-26 19:15:27 UTC
  • mto: This revision was merged to the branch mainline in revision 7055.
  • Revision ID: jelmer@jelmer.uk-20180726191527-wniq205k6tzfo1xx
Install fastimport from git.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/http_server.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
import errno
 
18
try:
 
19
    import http.client as http_client
 
20
    import http.server as http_server
 
21
except ImportError:
 
22
    import httplib as http_client
 
23
    import SimpleHTTPServer as http_server
 
24
import os
 
25
import posixpath
 
26
import random
 
27
import re
 
28
import socket
 
29
import sys
 
30
try:
 
31
    from urlparse import urlparse
 
32
except ImportError:
 
33
    from urllib.parse import urlparse
 
34
 
 
35
from .. import (
 
36
    osutils,
 
37
    urlutils,
 
38
)
 
39
from . import test_server
 
40
 
 
41
 
 
42
class BadWebserverPath(ValueError):
 
43
    def __str__(self):
 
44
        return 'path %s is not in %s' % self.args
 
45
 
 
46
 
 
47
class TestingHTTPRequestHandler(http_server.SimpleHTTPRequestHandler):
 
48
    """Handles one request.
 
49
 
 
50
    A TestingHTTPRequestHandler is instantiated for every request received by
 
51
    the associated server. Note that 'request' here is inherited from the base
 
52
    TCPServer class, for the HTTP server it is really a connection which itself
 
53
    will handle one or several HTTP requests.
 
54
    """
 
55
    # Default protocol version
 
56
    protocol_version = 'HTTP/1.1'
 
57
 
 
58
    # The Message-like class used to parse the request headers
 
59
    MessageClass = http_client.HTTPMessage
 
60
 
 
61
    def setup(self):
 
62
        http_server.SimpleHTTPRequestHandler.setup(self)
 
63
        self._cwd = self.server._home_dir
 
64
        tcs = self.server.test_case_server
 
65
        if tcs.protocol_version is not None:
 
66
            # If the test server forced a protocol version, use it
 
67
            self.protocol_version = tcs.protocol_version
 
68
 
 
69
    def log_message(self, format, *args):
 
70
        tcs = self.server.test_case_server
 
71
        tcs.log('webserver - %s - - [%s] %s "%s" "%s"',
 
72
                self.address_string(),
 
73
                self.log_date_time_string(),
 
74
                format % args,
 
75
                self.headers.get('referer', '-'),
 
76
                self.headers.get('user-agent', '-'))
 
77
 
 
78
    def handle_one_request(self):
 
79
        """Handle a single HTTP request.
 
80
 
 
81
        We catch all socket errors occurring when the client close the
 
82
        connection early to avoid polluting the test results.
 
83
        """
 
84
        try:
 
85
            self._handle_one_request()
 
86
        except socket.error as e:
 
87
            # Any socket error should close the connection, but some errors are
 
88
            # due to the client closing early and we don't want to pollute test
 
89
            # results, so we raise only the others.
 
90
            self.close_connection = 1
 
91
            if (len(e.args) == 0
 
92
                or e.args[0] not in (errno.EPIPE, errno.ECONNRESET,
 
93
                                     errno.ECONNABORTED, errno.EBADF)):
 
94
                raise
 
95
 
 
96
    error_content_type = 'text/plain'
 
97
    error_message_format = '''\
 
98
Error code: %(code)s.
 
99
Message: %(message)s.
 
100
'''
 
101
 
 
102
    def send_error(self, code, message=None):
 
103
        """Send and log an error reply.
 
104
 
 
105
        We redefine the python-provided version to be able to set a 
 
106
        ``Content-Length`` header as some http/1.1 clients complain otherwise
 
107
        (see bug #568421).
 
108
 
 
109
        :param code: The HTTP error code.
 
110
 
 
111
        :param message: The explanation of the error code, Defaults to a short
 
112
             entry.
 
113
        """
 
114
 
 
115
        if message is None:
 
116
            try:
 
117
                message = self.responses[code][0]
 
118
            except KeyError:
 
119
                message = '???'
 
120
        self.log_error("code %d, message %s", code, message)
 
121
        content = (self.error_message_format %
 
122
                   {'code': code, 'message': message})
 
123
        self.send_response(code, message)
 
124
        self.send_header("Content-Type", self.error_content_type)
 
125
        self.send_header("Content-Length", "%d" % len(content))
 
126
        self.send_header('Connection', 'close')
 
127
        self.end_headers()
 
128
        if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
 
129
            self.wfile.write(content.encode('utf-8'))
 
130
 
 
131
    def _handle_one_request(self):
 
132
        http_server.SimpleHTTPRequestHandler.handle_one_request(self)
 
133
 
 
134
    _range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)?$')
 
135
    _tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
 
136
 
 
137
    def _parse_ranges(self, ranges_header, file_size):
 
138
        """Parse the range header value and returns ranges.
 
139
 
 
140
        RFC2616 14.35 says that syntactically invalid range specifiers MUST be
 
141
        ignored. In that case, we return None instead of a range list.
 
142
 
 
143
        :param ranges_header: The 'Range' header value.
 
144
 
 
145
        :param file_size: The size of the requested file.
 
146
 
 
147
        :return: A list of (start, end) tuples or None if some invalid range
 
148
            specifier is encountered.
 
149
        """
 
150
        if not ranges_header.startswith('bytes='):
 
151
            # Syntactically invalid header
 
152
            return None
 
153
 
 
154
        tail = None
 
155
        ranges = []
 
156
        ranges_header = ranges_header[len('bytes='):]
 
157
        for range_str in ranges_header.split(','):
 
158
            range_match = self._range_regexp.match(range_str)
 
159
            if range_match is not None:
 
160
                start = int(range_match.group('start'))
 
161
                end_match = range_match.group('end')
 
162
                if end_match is None:
 
163
                    # RFC2616 says end is optional and default to file_size
 
164
                    end = file_size
 
165
                else:
 
166
                    end = int(end_match)
 
167
                if start > end:
 
168
                    # Syntactically invalid range
 
169
                    return None
 
170
                ranges.append((start, end))
 
171
            else:
 
172
                tail_match = self._tail_regexp.match(range_str)
 
173
                if tail_match is not None:
 
174
                    tail = int(tail_match.group('tail'))
 
175
                else:
 
176
                    # Syntactically invalid range
 
177
                    return None
 
178
        if tail is not None:
 
179
            # Normalize tail into ranges
 
180
            ranges.append((max(0, file_size - tail), file_size))
 
181
 
 
182
        checked_ranges = []
 
183
        for start, end in ranges:
 
184
            if start >= file_size:
 
185
                # RFC2616 14.35, ranges are invalid if start >= file_size
 
186
                return None
 
187
            # RFC2616 14.35, end values should be truncated
 
188
            # to file_size -1 if they exceed it
 
189
            end = min(end, file_size - 1)
 
190
            checked_ranges.append((start, end))
 
191
        return checked_ranges
 
192
 
 
193
    def _header_line_length(self, keyword, value):
 
194
        header_line = '%s: %s\r\n' % (keyword, value)
 
195
        return len(header_line)
 
196
 
 
197
    def send_head(self):
 
198
        """Overrides base implementation to work around a bug in python2.5."""
 
199
        path = self.translate_path(self.path)
 
200
        if os.path.isdir(path) and not self.path.endswith('/'):
 
201
            # redirect browser - doing basically what apache does when
 
202
            # DirectorySlash option is On which is quite common (braindead, but
 
203
            # common)
 
204
            self.send_response(301)
 
205
            self.send_header("Location", self.path + "/")
 
206
            # Indicates that the body is empty for HTTP/1.1 clients
 
207
            self.send_header('Content-Length', '0')
 
208
            self.end_headers()
 
209
            return None
 
210
 
 
211
        return http_server.SimpleHTTPRequestHandler.send_head(self)
 
212
 
 
213
    def send_range_content(self, file, start, length):
 
214
        file.seek(start)
 
215
        self.wfile.write(file.read(length))
 
216
 
 
217
    def get_single_range(self, file, file_size, start, end):
 
218
        self.send_response(206)
 
219
        length = end - start + 1
 
220
        self.send_header('Accept-Ranges', 'bytes')
 
221
        self.send_header("Content-Length", "%d" % length)
 
222
 
 
223
        self.send_header("Content-Type", 'application/octet-stream')
 
224
        self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
 
225
                                                              end,
 
226
                                                              file_size))
 
227
        self.end_headers()
 
228
        self.send_range_content(file, start, length)
 
229
 
 
230
    def get_multiple_ranges(self, file, file_size, ranges):
 
231
        self.send_response(206)
 
232
        self.send_header('Accept-Ranges', 'bytes')
 
233
        boundary = '%d' % random.randint(0, 0x7FFFFFFF)
 
234
        self.send_header('Content-Type',
 
235
                         'multipart/byteranges; boundary=%s' % boundary)
 
236
        boundary_line = '--%s\r\n' % boundary
 
237
        # Calculate the Content-Length
 
238
        content_length = 0
 
239
        for (start, end) in ranges:
 
240
            content_length += len(boundary_line)
 
241
            content_length += self._header_line_length(
 
242
                'Content-type', 'application/octet-stream')
 
243
            content_length += self._header_line_length(
 
244
                'Content-Range', 'bytes %d-%d/%d' % (start, end, file_size))
 
245
            content_length += len('\r\n') # end headers
 
246
            content_length += end - start + 1
 
247
        content_length += len(boundary_line)
 
248
        self.send_header('Content-length', content_length)
 
249
        self.end_headers()
 
250
 
 
251
        # Send the multipart body
 
252
        for (start, end) in ranges:
 
253
            self.wfile.write(boundary_line)
 
254
            self.send_header('Content-type', 'application/octet-stream')
 
255
            self.send_header('Content-Range', 'bytes %d-%d/%d'
 
256
                             % (start, end, file_size))
 
257
            self.end_headers()
 
258
            self.send_range_content(file, start, end - start + 1)
 
259
        # Final boundary
 
260
        self.wfile.write(boundary_line)
 
261
 
 
262
    def do_GET(self):
 
263
        """Serve a GET request.
 
264
 
 
265
        Handles the Range header.
 
266
        """
 
267
        # Update statistics
 
268
        self.server.test_case_server.GET_request_nb += 1
 
269
 
 
270
        path = self.translate_path(self.path)
 
271
        ranges_header_value = self.headers.get('Range')
 
272
        if ranges_header_value is None or os.path.isdir(path):
 
273
            # Let the mother class handle most cases
 
274
            return http_server.SimpleHTTPRequestHandler.do_GET(self)
 
275
 
 
276
        try:
 
277
            # Always read in binary mode. Opening files in text
 
278
            # mode may cause newline translations, making the
 
279
            # actual size of the content transmitted *less* than
 
280
            # the content-length!
 
281
            f = open(path, 'rb')
 
282
        except IOError:
 
283
            self.send_error(404, "File not found")
 
284
            return
 
285
 
 
286
        file_size = os.fstat(f.fileno())[6]
 
287
        ranges = self._parse_ranges(ranges_header_value, file_size)
 
288
        if not ranges:
 
289
            # RFC2616 14.16 and 14.35 says that when a server
 
290
            # encounters unsatisfiable range specifiers, it
 
291
            # SHOULD return a 416.
 
292
            f.close()
 
293
            # FIXME: We SHOULD send a Content-Range header too,
 
294
            # but the implementation of send_error does not
 
295
            # allows that. So far.
 
296
            self.send_error(416, "Requested range not satisfiable")
 
297
            return
 
298
 
 
299
        if len(ranges) == 1:
 
300
            (start, end) = ranges[0]
 
301
            self.get_single_range(f, file_size, start, end)
 
302
        else:
 
303
            self.get_multiple_ranges(f, file_size, ranges)
 
304
        f.close()
 
305
 
 
306
    def translate_path(self, path):
 
307
        """Translate a /-separated PATH to the local filename syntax.
 
308
 
 
309
        If the server requires it, proxy the path before the usual translation
 
310
        """
 
311
        if self.server.test_case_server.proxy_requests:
 
312
            # We need to act as a proxy and accept absolute urls,
 
313
            # which SimpleHTTPRequestHandler (parent) is not
 
314
            # ready for. So we just drop the protocol://host:port
 
315
            # part in front of the request-url (because we know
 
316
            # we would not forward the request to *another*
 
317
            # proxy).
 
318
 
 
319
            # So we do what SimpleHTTPRequestHandler.translate_path
 
320
            # do beginning with python 2.4.3: abandon query
 
321
            # parameters, scheme, host port, etc (which ensure we
 
322
            # provide the right behaviour on all python versions).
 
323
            path = urlparse(path)[2]
 
324
            # And now, we can apply *our* trick to proxy files
 
325
            path += '-proxied'
 
326
 
 
327
        return self._translate_path(path)
 
328
 
 
329
    def _translate_path(self, path):
 
330
        """Translate a /-separated PATH to the local filename syntax.
 
331
 
 
332
        Note that we're translating http URLs here, not file URLs.
 
333
        The URL root location is the server's startup directory.
 
334
        Components that mean special things to the local file system
 
335
        (e.g. drive or directory names) are ignored.  (XXX They should
 
336
        probably be diagnosed.)
 
337
 
 
338
        Override from python standard library to stop it calling os.getcwd()
 
339
        """
 
340
        # abandon query parameters
 
341
        path = urlparse(path)[2]
 
342
        path = posixpath.normpath(urlutils.unquote(path))
 
343
        if sys.version_info[0] == 2:
 
344
             path = path.decode('utf-8')
 
345
        words = path.split('/')
 
346
        path = self._cwd
 
347
        for num, word in enumerate(w for w in words if w):
 
348
            if num == 0:
 
349
                drive, word = os.path.splitdrive(word)
 
350
            head, word = os.path.split(word)
 
351
            if word in (os.curdir, os.pardir): continue
 
352
            path = os.path.join(path, word)
 
353
        return path
 
354
 
 
355
 
 
356
class TestingHTTPServerMixin:
 
357
 
 
358
    def __init__(self, test_case_server):
 
359
        # test_case_server can be used to communicate between the
 
360
        # tests and the server (or the request handler and the
 
361
        # server), allowing dynamic behaviors to be defined from
 
362
        # the tests cases.
 
363
        self.test_case_server = test_case_server
 
364
        self._home_dir = test_case_server._home_dir
 
365
 
 
366
 
 
367
class TestingHTTPServer(test_server.TestingTCPServer, TestingHTTPServerMixin):
 
368
 
 
369
    def __init__(self, server_address, request_handler_class,
 
370
                 test_case_server):
 
371
        test_server.TestingTCPServer.__init__(self, server_address,
 
372
                                              request_handler_class)
 
373
        TestingHTTPServerMixin.__init__(self, test_case_server)
 
374
 
 
375
 
 
376
class TestingThreadingHTTPServer(test_server.TestingThreadingTCPServer,
 
377
                                 TestingHTTPServerMixin):
 
378
    """A threading HTTP test server for HTTP 1.1.
 
379
 
 
380
    Since tests can initiate several concurrent connections to the same http
 
381
    server, we need an independent connection for each of them. We achieve that
 
382
    by spawning a new thread for each connection.
 
383
    """
 
384
    def __init__(self, server_address, request_handler_class,
 
385
                 test_case_server):
 
386
        test_server.TestingThreadingTCPServer.__init__(self, server_address,
 
387
                                                       request_handler_class)
 
388
        TestingHTTPServerMixin.__init__(self, test_case_server)
 
389
 
 
390
 
 
391
class HttpServer(test_server.TestingTCPServerInAThread):
 
392
    """A test server for http transports.
 
393
 
 
394
    Subclasses can provide a specific request handler.
 
395
    """
 
396
 
 
397
    # The real servers depending on the protocol
 
398
    http_server_class = {'HTTP/1.0': TestingHTTPServer,
 
399
                         'HTTP/1.1': TestingThreadingHTTPServer,
 
400
                         }
 
401
 
 
402
    # Whether or not we proxy the requests (see
 
403
    # TestingHTTPRequestHandler.translate_path).
 
404
    proxy_requests = False
 
405
 
 
406
    # used to form the url that connects to this server
 
407
    _url_protocol = 'http'
 
408
 
 
409
    def __init__(self, request_handler=TestingHTTPRequestHandler,
 
410
                 protocol_version=None):
 
411
        """Constructor.
 
412
 
 
413
        :param request_handler: a class that will be instantiated to handle an
 
414
            http connection (one or several requests).
 
415
 
 
416
        :param protocol_version: if specified, will override the protocol
 
417
            version of the request handler.
 
418
        """
 
419
        # Depending on the protocol version, we will create the approriate
 
420
        # server
 
421
        if protocol_version is None:
 
422
            # Use the request handler one
 
423
            proto_vers = request_handler.protocol_version
 
424
        else:
 
425
            # Use our own, it will be used to override the request handler
 
426
            # one too.
 
427
            proto_vers = protocol_version
 
428
        # Get the appropriate server class for the required protocol
 
429
        serv_cls = self.http_server_class.get(proto_vers, None)
 
430
        if serv_cls is None:
 
431
            raise http_client.UnknownProtocol(proto_vers)
 
432
        self.host = 'localhost'
 
433
        self.port = 0
 
434
        super(HttpServer, self).__init__((self.host, self.port),
 
435
                                         serv_cls,
 
436
                                         request_handler)
 
437
        self.protocol_version = proto_vers
 
438
        # Allows tests to verify number of GET requests issued
 
439
        self.GET_request_nb = 0
 
440
        self._http_base_url = None
 
441
        self.logs = []
 
442
 
 
443
    def create_server(self):
 
444
        return self.server_class(
 
445
            (self.host, self.port), self.request_handler_class, self)
 
446
 
 
447
    def _get_remote_url(self, path):
 
448
        path_parts = path.split(os.path.sep)
 
449
        if os.path.isabs(path):
 
450
            if path_parts[:len(self._local_path_parts)] != \
 
451
                   self._local_path_parts:
 
452
                raise BadWebserverPath(path, self.test_dir)
 
453
            remote_path = '/'.join(path_parts[len(self._local_path_parts):])
 
454
        else:
 
455
            remote_path = '/'.join(path_parts)
 
456
 
 
457
        return self._http_base_url + remote_path
 
458
 
 
459
    def log(self, format, *args):
 
460
        """Capture Server log output."""
 
461
        self.logs.append(format % args)
 
462
 
 
463
    def start_server(self, backing_transport_server=None):
 
464
        """See breezy.transport.Server.start_server.
 
465
 
 
466
        :param backing_transport_server: The transport that requests over this
 
467
            protocol should be forwarded to. Note that this is currently not
 
468
            supported for HTTP.
 
469
        """
 
470
        # XXX: TODO: make the server back onto vfs_server rather than local
 
471
        # disk.
 
472
        if not (backing_transport_server is None
 
473
                or isinstance(backing_transport_server,
 
474
                              test_server.LocalURLServer)):
 
475
            raise AssertionError(
 
476
                "HTTPServer currently assumes local transport, got %s" %
 
477
                backing_transport_server)
 
478
        self._home_dir = osutils.getcwd()
 
479
        self._local_path_parts = self._home_dir.split(os.path.sep)
 
480
        self.logs = []
 
481
 
 
482
        super(HttpServer, self).start_server()
 
483
        self._http_base_url = '%s://%s:%s/' % (
 
484
            self._url_protocol, self.host, self.port)
 
485
 
 
486
    def get_url(self):
 
487
        """See breezy.transport.Server.get_url."""
 
488
        return self._get_remote_url(self._home_dir)
 
489
 
 
490
    def get_bogus_url(self):
 
491
        """See breezy.transport.Server.get_bogus_url."""
 
492
        # this is chosen to try to prevent trouble with proxies, weird dns,
 
493
        # etc
 
494
        return self._url_protocol + '://127.0.0.1:1/'