/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-11-23 01:35:56 UTC
  • mto: (7211.10.3 git-empty-dirs)
  • mto: This revision was merged to the branch mainline in revision 7215.
  • Revision ID: jelmer@jelmer.uk-20181123013556-mu7ct9ovl7fozjc2
Update comment about ssl.

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 = b'--%s\r\n' % boundary.encode('ascii')
 
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):
 
352
                continue
 
353
            path = os.path.join(path, word)
 
354
        return path
 
355
 
 
356
 
 
357
class TestingHTTPServerMixin:
 
358
 
 
359
    def __init__(self, test_case_server):
 
360
        # test_case_server can be used to communicate between the
 
361
        # tests and the server (or the request handler and the
 
362
        # server), allowing dynamic behaviors to be defined from
 
363
        # the tests cases.
 
364
        self.test_case_server = test_case_server
 
365
        self._home_dir = test_case_server._home_dir
 
366
 
 
367
 
 
368
class TestingHTTPServer(test_server.TestingTCPServer, TestingHTTPServerMixin):
 
369
 
 
370
    def __init__(self, server_address, request_handler_class,
 
371
                 test_case_server):
 
372
        test_server.TestingTCPServer.__init__(self, server_address,
 
373
                                              request_handler_class)
 
374
        TestingHTTPServerMixin.__init__(self, test_case_server)
 
375
 
 
376
 
 
377
class TestingThreadingHTTPServer(test_server.TestingThreadingTCPServer,
 
378
                                 TestingHTTPServerMixin):
 
379
    """A threading HTTP test server for HTTP 1.1.
 
380
 
 
381
    Since tests can initiate several concurrent connections to the same http
 
382
    server, we need an independent connection for each of them. We achieve that
 
383
    by spawning a new thread for each connection.
 
384
    """
 
385
 
 
386
    def __init__(self, server_address, request_handler_class,
 
387
                 test_case_server):
 
388
        test_server.TestingThreadingTCPServer.__init__(self, server_address,
 
389
                                                       request_handler_class)
 
390
        TestingHTTPServerMixin.__init__(self, test_case_server)
 
391
 
 
392
 
 
393
class HttpServer(test_server.TestingTCPServerInAThread):
 
394
    """A test server for http transports.
 
395
 
 
396
    Subclasses can provide a specific request handler.
 
397
    """
 
398
 
 
399
    # The real servers depending on the protocol
 
400
    http_server_class = {'HTTP/1.0': TestingHTTPServer,
 
401
                         'HTTP/1.1': TestingThreadingHTTPServer,
 
402
                         }
 
403
 
 
404
    # Whether or not we proxy the requests (see
 
405
    # TestingHTTPRequestHandler.translate_path).
 
406
    proxy_requests = False
 
407
 
 
408
    # used to form the url that connects to this server
 
409
    _url_protocol = 'http'
 
410
 
 
411
    def __init__(self, request_handler=TestingHTTPRequestHandler,
 
412
                 protocol_version=None):
 
413
        """Constructor.
 
414
 
 
415
        :param request_handler: a class that will be instantiated to handle an
 
416
            http connection (one or several requests).
 
417
 
 
418
        :param protocol_version: if specified, will override the protocol
 
419
            version of the request handler.
 
420
        """
 
421
        # Depending on the protocol version, we will create the approriate
 
422
        # server
 
423
        if protocol_version is None:
 
424
            # Use the request handler one
 
425
            proto_vers = request_handler.protocol_version
 
426
        else:
 
427
            # Use our own, it will be used to override the request handler
 
428
            # one too.
 
429
            proto_vers = protocol_version
 
430
        # Get the appropriate server class for the required protocol
 
431
        serv_cls = self.http_server_class.get(proto_vers, None)
 
432
        if serv_cls is None:
 
433
            raise http_client.UnknownProtocol(proto_vers)
 
434
        self.host = 'localhost'
 
435
        self.port = 0
 
436
        super(HttpServer, self).__init__((self.host, self.port),
 
437
                                         serv_cls,
 
438
                                         request_handler)
 
439
        self.protocol_version = proto_vers
 
440
        # Allows tests to verify number of GET requests issued
 
441
        self.GET_request_nb = 0
 
442
        self._http_base_url = None
 
443
        self.logs = []
 
444
 
 
445
    def create_server(self):
 
446
        return self.server_class(
 
447
            (self.host, self.port), self.request_handler_class, self)
 
448
 
 
449
    def _get_remote_url(self, path):
 
450
        path_parts = path.split(os.path.sep)
 
451
        if os.path.isabs(path):
 
452
            if path_parts[:len(self._local_path_parts)] != \
 
453
                    self._local_path_parts:
 
454
                raise BadWebserverPath(path, self.test_dir)
 
455
            remote_path = '/'.join(path_parts[len(self._local_path_parts):])
 
456
        else:
 
457
            remote_path = '/'.join(path_parts)
 
458
 
 
459
        return self._http_base_url + remote_path
 
460
 
 
461
    def log(self, format, *args):
 
462
        """Capture Server log output."""
 
463
        self.logs.append(format % args)
 
464
 
 
465
    def start_server(self, backing_transport_server=None):
 
466
        """See breezy.transport.Server.start_server.
 
467
 
 
468
        :param backing_transport_server: The transport that requests over this
 
469
            protocol should be forwarded to. Note that this is currently not
 
470
            supported for HTTP.
 
471
        """
 
472
        # XXX: TODO: make the server back onto vfs_server rather than local
 
473
        # disk.
 
474
        if not (backing_transport_server is None
 
475
                or isinstance(backing_transport_server,
 
476
                              test_server.LocalURLServer)):
 
477
            raise AssertionError(
 
478
                "HTTPServer currently assumes local transport, got %s" %
 
479
                backing_transport_server)
 
480
        self._home_dir = osutils.getcwd()
 
481
        self._local_path_parts = self._home_dir.split(os.path.sep)
 
482
        self.logs = []
 
483
 
 
484
        super(HttpServer, self).start_server()
 
485
        self._http_base_url = '%s://%s:%s/' % (
 
486
            self._url_protocol, self.host, self.port)
 
487
 
 
488
    def get_url(self):
 
489
        """See breezy.transport.Server.get_url."""
 
490
        return self._get_remote_url(self._home_dir)
 
491
 
 
492
    def get_bogus_url(self):
 
493
        """See breezy.transport.Server.get_bogus_url."""
 
494
        # this is chosen to try to prevent trouble with proxies, weird dns,
 
495
        # etc
 
496
        return self._url_protocol + '://127.0.0.1:1/'