← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/http_server.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-06-22 17:11:20 UTC
  • mfrom: (4398.8.10 1.16-commit-fulltext)
  • Revision ID: pqm@pqm.ubuntu.com-20090622171120-fuxez9ylfqpxynqn
(jam) Add VF._add_text and reduce memory overhead during commit (see
        bug #109114)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/http_server.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 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
20
20
import posixpath
21
21
import random
22
22
import re
 
23
import select
23
24
import SimpleHTTPServer
24
25
import socket
 
26
import SocketServer
 
27
import sys
 
28
import threading
 
29
import time
25
30
import urllib
26
31
import urlparse
27
32
 
28
 
from bzrlib.tests import test_server
 
33
from bzrlib import transport
 
34
from bzrlib.transport import local
29
35
 
30
36
 
31
37
class BadWebserverPath(ValueError):
64
70
                self.headers.get('referer', '-'),
65
71
                self.headers.get('user-agent', '-'))
66
72
 
67
 
    def handle(self):
68
 
        SimpleHTTPServer.SimpleHTTPRequestHandler.handle(self)
69
 
        # Some client (pycurl, I'm looking at you) are more picky than others
70
 
        # and require that the socket itself is closed
71
 
        # (SocketServer.StreamRequestHandler only close the two associated
72
 
        # 'makefile' objects)
73
 
        self.connection.close()
74
 
 
75
73
    def handle_one_request(self):
76
74
        """Handle a single HTTP request.
77
75
 
79
77
        connection early to avoid polluting the test results.
80
78
        """
81
79
        try:
82
 
            self._handle_one_request()
 
80
            SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
83
81
        except socket.error, e:
84
82
            # Any socket error should close the connection, but some errors are
85
83
            # due to the client closing early and we don't want to pollute test
90
88
                                     errno.ECONNABORTED, errno.EBADF)):
91
89
                raise
92
90
 
93
 
    error_content_type = 'text/plain'
94
 
    error_message_format = '''\
95
 
Error code: %(code)s.
96
 
Message: %(message)s.
97
 
'''
98
 
 
99
 
    def send_error(self, code, message=None):
100
 
        """Send and log an error reply.
101
 
 
102
 
        We redefine the python-provided version to be able to set a 
103
 
        ``Content-Length`` header as some http/1.1 clients complain otherwise
104
 
        (see bug #568421).
105
 
 
106
 
        :param code: The HTTP error code.
107
 
 
108
 
        :param message: The explanation of the error code, Defaults to a short
109
 
             entry.
110
 
        """
111
 
 
112
 
        if message is None:
113
 
            try:
114
 
                message = self.responses[code][0]
115
 
            except KeyError:
116
 
                message = '???'
117
 
        self.log_error("code %d, message %s", code, message)
118
 
        content = (self.error_message_format %
119
 
                   {'code': code, 'message': message})
120
 
        self.send_response(code, message)
121
 
        self.send_header("Content-Type", self.error_content_type)
122
 
        self.send_header("Content-Length", "%d" % len(content))
123
 
        self.send_header('Connection', 'close')
124
 
        self.end_headers()
125
 
        if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
126
 
            self.wfile.write(content)
127
 
 
128
 
    def _handle_one_request(self):
129
 
        SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
130
 
 
131
 
    _range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)?$')
 
91
    _range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
132
92
    _tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
133
93
 
134
 
    def _parse_ranges(self, ranges_header, file_size):
135
 
        """Parse the range header value and returns ranges.
136
 
 
137
 
        RFC2616 14.35 says that syntactically invalid range specifiers MUST be
138
 
        ignored. In that case, we return None instead of a range list.
139
 
 
140
 
        :param ranges_header: The 'Range' header value.
141
 
 
142
 
        :param file_size: The size of the requested file.
143
 
 
144
 
        :return: A list of (start, end) tuples or None if some invalid range
145
 
            specifier is encountered.
 
94
    def parse_ranges(self, ranges_header):
 
95
        """Parse the range header value and returns ranges and tail.
 
96
 
 
97
        RFC2616 14.35 says that syntactically invalid range
 
98
        specifiers MUST be ignored. In that case, we return 0 for
 
99
        tail and [] for ranges.
146
100
        """
 
101
        tail = 0
 
102
        ranges = []
147
103
        if not ranges_header.startswith('bytes='):
148
104
            # Syntactically invalid header
149
 
            return None
 
105
            return 0, []
150
106
 
151
 
        tail = None
152
 
        ranges = []
153
107
        ranges_header = ranges_header[len('bytes='):]
154
108
        for range_str in ranges_header.split(','):
 
109
            # FIXME: RFC2616 says end is optional and default to file_size
155
110
            range_match = self._range_regexp.match(range_str)
156
111
            if range_match is not None:
157
112
                start = int(range_match.group('start'))
158
 
                end_match = range_match.group('end')
159
 
                if end_match is None:
160
 
                    # RFC2616 says end is optional and default to file_size
161
 
                    end = file_size
162
 
                else:
163
 
                    end = int(end_match)
 
113
                end = int(range_match.group('end'))
164
114
                if start > end:
165
115
                    # Syntactically invalid range
166
 
                    return None
 
116
                    return 0, []
167
117
                ranges.append((start, end))
168
118
            else:
169
119
                tail_match = self._tail_regexp.match(range_str)
171
121
                    tail = int(tail_match.group('tail'))
172
122
                else:
173
123
                    # Syntactically invalid range
174
 
                    return None
175
 
        if tail is not None:
176
 
            # Normalize tail into ranges
177
 
            ranges.append((max(0, file_size - tail), file_size))
178
 
 
179
 
        checked_ranges = []
180
 
        for start, end in ranges:
181
 
            if start >= file_size:
182
 
                # RFC2616 14.35, ranges are invalid if start >= file_size
183
 
                return None
184
 
            # RFC2616 14.35, end values should be truncated
185
 
            # to file_size -1 if they exceed it
186
 
            end = min(end, file_size - 1)
187
 
            checked_ranges.append((start, end))
188
 
        return checked_ranges
 
124
                    return 0, []
 
125
        return tail, ranges
189
126
 
190
127
    def _header_line_length(self, keyword, value):
191
128
        header_line = '%s: %s\r\n' % (keyword, value)
275
212
            # mode may cause newline translations, making the
276
213
            # actual size of the content transmitted *less* than
277
214
            # the content-length!
278
 
            f = open(path, 'rb')
 
215
            file = open(path, 'rb')
279
216
        except IOError:
280
217
            self.send_error(404, "File not found")
281
218
            return
282
219
 
283
 
        file_size = os.fstat(f.fileno())[6]
284
 
        ranges = self._parse_ranges(ranges_header_value, file_size)
285
 
        if not ranges:
 
220
        file_size = os.fstat(file.fileno())[6]
 
221
        tail, ranges = self.parse_ranges(ranges_header_value)
 
222
        # Normalize tail into ranges
 
223
        if tail != 0:
 
224
            ranges.append((file_size - tail, file_size))
 
225
 
 
226
        self._satisfiable_ranges = True
 
227
        if len(ranges) == 0:
 
228
            self._satisfiable_ranges = False
 
229
        else:
 
230
            def check_range(range_specifier):
 
231
                start, end = range_specifier
 
232
                # RFC2616 14.35, ranges are invalid if start >= file_size
 
233
                if start >= file_size:
 
234
                    self._satisfiable_ranges = False # Side-effect !
 
235
                    return 0, 0
 
236
                # RFC2616 14.35, end values should be truncated
 
237
                # to file_size -1 if they exceed it
 
238
                end = min(end, file_size - 1)
 
239
                return start, end
 
240
 
 
241
            ranges = map(check_range, ranges)
 
242
 
 
243
        if not self._satisfiable_ranges:
286
244
            # RFC2616 14.16 and 14.35 says that when a server
287
245
            # encounters unsatisfiable range specifiers, it
288
246
            # SHOULD return a 416.
289
 
            f.close()
 
247
            file.close()
290
248
            # FIXME: We SHOULD send a Content-Range header too,
291
249
            # but the implementation of send_error does not
292
250
            # allows that. So far.
295
253
 
296
254
        if len(ranges) == 1:
297
255
            (start, end) = ranges[0]
298
 
            self.get_single_range(f, file_size, start, end)
 
256
            self.get_single_range(file, file_size, start, end)
299
257
        else:
300
 
            self.get_multiple_ranges(f, file_size, ranges)
301
 
        f.close()
 
258
            self.get_multiple_ranges(file, file_size, ranges)
 
259
        file.close()
302
260
 
303
261
    def translate_path(self, path):
304
262
        """Translate a /-separated PATH to the local filename syntax.
360
318
        self.test_case_server = test_case_server
361
319
        self._home_dir = test_case_server._home_dir
362
320
 
363
 
 
364
 
class TestingHTTPServer(test_server.TestingTCPServer, TestingHTTPServerMixin):
 
321
    def tearDown(self):
 
322
         """Called to clean-up the server.
 
323
 
 
324
         Since the server may be (surely is, even) in a blocking listen, we
 
325
         shutdown its socket before closing it.
 
326
         """
 
327
         # Note that is this executed as part of the implicit tear down in the
 
328
         # main thread while the server runs in its own thread. The clean way
 
329
         # to tear down the server is to instruct him to stop accepting
 
330
         # connections and wait for the current connection(s) to end
 
331
         # naturally. To end the connection naturally, the http transports
 
332
         # should close their socket when they do not need to talk to the
 
333
         # server anymore. This happens naturally during the garbage collection
 
334
         # phase of the test transport objetcs (the server clients), so we
 
335
         # don't have to worry about them.  So, for the server, we must tear
 
336
         # down here, from the main thread, when the test have ended.  Note
 
337
         # that since the server is in a blocking operation and since python
 
338
         # use select internally, shutting down the socket is reliable and
 
339
         # relatively clean.
 
340
         try:
 
341
             self.socket.shutdown(socket.SHUT_RDWR)
 
342
         except socket.error, e:
 
343
             # WSAENOTCONN (10057) 'Socket is not connected' is harmless on
 
344
             # windows (occurs before the first connection attempt
 
345
             # vila--20071230)
 
346
 
 
347
             # 'Socket is not connected' can also occur on OSX, with a
 
348
             # "regular" ENOTCONN (when something went wrong during test case
 
349
             # setup leading to self.setUp() *not* being called but
 
350
             # self.tearDown() still being called -- vila20081106
 
351
             if not len(e.args) or e.args[0] not in (errno.ENOTCONN, 10057):
 
352
                 raise
 
353
         # Let the server properly close the socket
 
354
         self.server_close()
 
355
 
 
356
 
 
357
class TestingHTTPServer(SocketServer.TCPServer, TestingHTTPServerMixin):
365
358
 
366
359
    def __init__(self, server_address, request_handler_class,
367
360
                 test_case_server):
368
 
        test_server.TestingTCPServer.__init__(self, server_address,
369
 
                                              request_handler_class)
370
361
        TestingHTTPServerMixin.__init__(self, test_case_server)
371
 
 
372
 
 
373
 
class TestingThreadingHTTPServer(test_server.TestingThreadingTCPServer,
 
362
        SocketServer.TCPServer.__init__(self, server_address,
 
363
                                        request_handler_class)
 
364
 
 
365
 
 
366
class TestingThreadingHTTPServer(SocketServer.ThreadingTCPServer,
374
367
                                 TestingHTTPServerMixin):
375
368
    """A threading HTTP test server for HTTP 1.1.
376
369
 
378
371
    server, we need an independent connection for each of them. We achieve that
379
372
    by spawning a new thread for each connection.
380
373
    """
 
374
 
381
375
    def __init__(self, server_address, request_handler_class,
382
376
                 test_case_server):
383
 
        test_server.TestingThreadingTCPServer.__init__(self, server_address,
384
 
                                                       request_handler_class)
385
377
        TestingHTTPServerMixin.__init__(self, test_case_server)
386
 
 
387
 
 
388
 
class HttpServer(test_server.TestingTCPServerInAThread):
 
378
        SocketServer.ThreadingTCPServer.__init__(self, server_address,
 
379
                                                 request_handler_class)
 
380
        # Decides how threads will act upon termination of the main
 
381
        # process. This is prophylactic as we should not leave the threads
 
382
        # lying around.
 
383
        self.daemon_threads = True
 
384
 
 
385
 
 
386
class HttpServer(transport.Server):
389
387
    """A test server for http transports.
390
388
 
391
389
    Subclasses can provide a specific request handler.
413
411
        :param protocol_version: if specified, will override the protocol
414
412
            version of the request handler.
415
413
        """
416
 
        # Depending on the protocol version, we will create the approriate
417
 
        # server
418
 
        if protocol_version is None:
419
 
            # Use the request handler one
420
 
            proto_vers = request_handler.protocol_version
421
 
        else:
422
 
            # Use our own, it will be used to override the request handler
423
 
            # one too.
424
 
            proto_vers = protocol_version
425
 
        # Get the appropriate server class for the required protocol
426
 
        serv_cls = self.http_server_class.get(proto_vers, None)
427
 
        if serv_cls is None:
428
 
            raise httplib.UnknownProtocol(proto_vers)
 
414
        transport.Server.__init__(self)
 
415
        self.request_handler = request_handler
429
416
        self.host = 'localhost'
430
417
        self.port = 0
431
 
        super(HttpServer, self).__init__((self.host, self.port),
432
 
                                         serv_cls,
433
 
                                         request_handler)
434
 
        self.protocol_version = proto_vers
 
418
        self._httpd = None
 
419
        self.protocol_version = protocol_version
435
420
        # Allows tests to verify number of GET requests issued
436
421
        self.GET_request_nb = 0
437
 
        self._http_base_url = None
438
 
        self.logs = []
439
 
 
440
 
    def create_server(self):
441
 
        return self.server_class(
442
 
            (self.host, self.port), self.request_handler_class, self)
 
422
 
 
423
    def create_httpd(self, serv_cls, rhandler_cls):
 
424
        return serv_cls((self.host, self.port), self.request_handler, self)
 
425
 
 
426
    def __repr__(self):
 
427
        return "%s(%s:%s)" % \
 
428
            (self.__class__.__name__, self.host, self.port)
 
429
 
 
430
    def _get_httpd(self):
 
431
        if self._httpd is None:
 
432
            rhandler = self.request_handler
 
433
            # Depending on the protocol version, we will create the approriate
 
434
            # server
 
435
            if self.protocol_version is None:
 
436
                # Use the request handler one
 
437
                proto_vers = rhandler.protocol_version
 
438
            else:
 
439
                # Use our own, it will be used to override the request handler
 
440
                # one too.
 
441
                proto_vers = self.protocol_version
 
442
            # Create the appropriate server for the required protocol
 
443
            serv_cls = self.http_server_class.get(proto_vers, None)
 
444
            if serv_cls is None:
 
445
                raise httplib.UnknownProtocol(proto_vers)
 
446
            else:
 
447
                self._httpd = self.create_httpd(serv_cls, rhandler)
 
448
            host, self.port = self._httpd.socket.getsockname()
 
449
        return self._httpd
 
450
 
 
451
    def _http_start(self):
 
452
        """Server thread main entry point. """
 
453
        self._http_running = False
 
454
        try:
 
455
            try:
 
456
                httpd = self._get_httpd()
 
457
                self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
 
458
                                                       self.host, self.port)
 
459
                self._http_running = True
 
460
            except:
 
461
                # Whatever goes wrong, we save the exception for the main
 
462
                # thread. Note that since we are running in a thread, no signal
 
463
                # can be received, so we don't care about KeyboardInterrupt.
 
464
                self._http_exception = sys.exc_info()
 
465
        finally:
 
466
            # Release the lock or the main thread will block and the whole
 
467
            # process will hang.
 
468
            self._http_starting.release()
 
469
 
 
470
        # From now on, exceptions are taken care of by the
 
471
        # SocketServer.BaseServer or the request handler.
 
472
        while self._http_running:
 
473
            try:
 
474
                # Really an HTTP connection but the python framework is generic
 
475
                # and call them requests
 
476
                httpd.handle_request()
 
477
            except socket.timeout:
 
478
                pass
 
479
            except (socket.error, select.error), e:
 
480
               if e[0] == errno.EBADF:
 
481
                   # Starting with python-2.6, handle_request may raise socket
 
482
                   # or select exceptions when the server is shut down (as we
 
483
                   # do).
 
484
                   pass
 
485
               else:
 
486
                   raise
443
487
 
444
488
    def _get_remote_url(self, path):
445
489
        path_parts = path.split(os.path.sep)
457
501
        """Capture Server log output."""
458
502
        self.logs.append(format % args)
459
503
 
460
 
    def start_server(self, backing_transport_server=None):
461
 
        """See bzrlib.transport.Server.start_server.
 
504
    def setUp(self, backing_transport_server=None):
 
505
        """See bzrlib.transport.Server.setUp.
462
506
 
463
507
        :param backing_transport_server: The transport that requests over this
464
508
            protocol should be forwarded to. Note that this is currently not
466
510
        """
467
511
        # XXX: TODO: make the server back onto vfs_server rather than local
468
512
        # disk.
469
 
        if not (backing_transport_server is None
470
 
                or isinstance(backing_transport_server,
471
 
                              test_server.LocalURLServer)):
 
513
        if not (backing_transport_server is None or \
 
514
                isinstance(backing_transport_server, local.LocalURLServer)):
472
515
            raise AssertionError(
473
 
                "HTTPServer currently assumes local transport, got %s" %
 
516
                "HTTPServer currently assumes local transport, got %s" % \
474
517
                backing_transport_server)
475
518
        self._home_dir = os.getcwdu()
476
519
        self._local_path_parts = self._home_dir.split(os.path.sep)
 
520
        self._http_base_url = None
 
521
 
 
522
        # Create the server thread
 
523
        self._http_starting = threading.Lock()
 
524
        self._http_starting.acquire()
 
525
        self._http_thread = threading.Thread(target=self._http_start)
 
526
        self._http_thread.setDaemon(True)
 
527
        self._http_exception = None
 
528
        self._http_thread.start()
 
529
 
 
530
        # Wait for the server thread to start (i.e release the lock)
 
531
        self._http_starting.acquire()
 
532
 
 
533
        if self._http_exception is not None:
 
534
            # Something went wrong during server start
 
535
            exc_class, exc_value, exc_tb = self._http_exception
 
536
            raise exc_class, exc_value, exc_tb
 
537
        self._http_starting.release()
477
538
        self.logs = []
478
539
 
479
 
        super(HttpServer, self).start_server()
480
 
        self._http_base_url = '%s://%s:%s/' % (
481
 
            self._url_protocol, self.host, self.port)
 
540
    def tearDown(self):
 
541
        """See bzrlib.transport.Server.tearDown."""
 
542
        self._httpd.tearDown()
 
543
        self._http_running = False
 
544
        # We don't need to 'self._http_thread.join()' here since the thread is
 
545
        # a daemonic one and will be garbage collected anyway. Joining just
 
546
        # slows us down for no added benefit.
482
547
 
483
548
    def get_url(self):
484
549
        """See bzrlib.transport.Server.get_url."""