← 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: 2008-03-16 14:01:20 UTC
  • mfrom: (3280.2.5 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20080316140120-i3yq8yr1l66m11h7
Start 1.4 development

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/http_server.py
1
 
# Copyright (C) 2006-2010 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
import errno
18
18
import httplib
20
20
import posixpath
21
21
import random
22
22
import re
23
 
import select
24
23
import SimpleHTTPServer
25
24
import socket
26
25
import SocketServer
30
29
import urllib
31
30
import urlparse
32
31
 
33
 
from bzrlib import (
34
 
    osutils,
35
 
    tests,
36
 
    transport,
37
 
    )
38
 
from bzrlib.tests import test_server
 
32
from bzrlib import transport
39
33
from bzrlib.transport import local
40
34
 
41
35
 
 
36
class WebserverNotAvailable(Exception):
 
37
    pass
 
38
 
 
39
 
42
40
class BadWebserverPath(ValueError):
43
41
    def __str__(self):
44
42
        return 'path %s is not in %s' % self.args
60
58
 
61
59
    def setup(self):
62
60
        SimpleHTTPServer.SimpleHTTPRequestHandler.setup(self)
63
 
        self._cwd = self.server._home_dir
64
61
        tcs = self.server.test_case_server
65
62
        if tcs.protocol_version is not None:
66
63
            # If the test server forced a protocol version, use it
75
72
                self.headers.get('referer', '-'),
76
73
                self.headers.get('user-agent', '-'))
77
74
 
78
 
    def handle(self):
79
 
        SimpleHTTPServer.SimpleHTTPRequestHandler.handle(self)
80
 
        # Some client (pycurl, I'm looking at you) are more picky than others
81
 
        # and require that the socket itself is closed
82
 
        # (SocketServer.StreamRequestHandler only close the two associated
83
 
        # 'makefile' objects)
84
 
        self.connection.close()
85
 
 
86
75
    def handle_one_request(self):
87
76
        """Handle a single HTTP request.
88
77
 
90
79
        connection early to avoid polluting the test results.
91
80
        """
92
81
        try:
93
 
            self._handle_one_request()
 
82
            SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
94
83
        except socket.error, e:
95
84
            # Any socket error should close the connection, but some errors are
96
85
            # due to the client closing early and we don't want to pollute test
101
90
                                     errno.ECONNABORTED, errno.EBADF)):
102
91
                raise
103
92
 
104
 
    error_content_type = 'text/plain'
105
 
    error_message_format = '''\
106
 
Error code: %(code)s.
107
 
Message: %(message)s.
108
 
'''
109
 
 
110
 
    def send_error(self, code, message=None):
111
 
        """Send and log an error reply.
112
 
 
113
 
        We redefine the python-provided version to be able to set a 
114
 
        ``Content-Length`` header as some http/1.1 clients complain otherwise
115
 
        (see bug #568421).
116
 
 
117
 
        :param code: The HTTP error code.
118
 
 
119
 
        :param message: The explanation of the error code, Defaults to a short
120
 
             entry.
121
 
        """
122
 
 
123
 
        if message is None:
124
 
            try:
125
 
                message = self.responses[code][0]
126
 
            except KeyError:
127
 
                message = '???'
128
 
        self.log_error("code %d, message %s", code, message)
129
 
        content = (self.error_message_format %
130
 
                   {'code': code, 'message': message})
131
 
        self.send_response(code, message)
132
 
        self.send_header("Content-Type", self.error_content_type)
133
 
        self.send_header("Content-Length", "%d" % len(content))
134
 
        self.send_header('Connection', 'close')
135
 
        self.end_headers()
136
 
        if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
137
 
            self.wfile.write(content)
138
 
 
139
 
    def _handle_one_request(self):
140
 
        SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
141
 
 
142
93
    _range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
143
94
    _tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
144
95
 
188
139
            # common)
189
140
            self.send_response(301)
190
141
            self.send_header("Location", self.path + "/")
191
 
            # Indicates that the body is empty for HTTP/1.1 clients
 
142
            # Indicates that the body is empty for HTTP/1.1 clients 
192
143
            self.send_header('Content-Length', '0')
193
144
            self.end_headers()
194
145
            return None
228
179
            content_length += self._header_line_length(
229
180
                'Content-Range', 'bytes %d-%d/%d' % (start, end, file_size))
230
181
            content_length += len('\r\n') # end headers
231
 
            content_length += end - start + 1
 
182
            content_length += end - start # + 1
232
183
        content_length += len(boundary_line)
233
184
        self.send_header('Content-length', content_length)
234
185
        self.end_headers()
263
214
            # mode may cause newline translations, making the
264
215
            # actual size of the content transmitted *less* than
265
216
            # the content-length!
266
 
            f = open(path, 'rb')
 
217
            file = open(path, 'rb')
267
218
        except IOError:
268
219
            self.send_error(404, "File not found")
269
220
            return
270
221
 
271
 
        file_size = os.fstat(f.fileno())[6]
 
222
        file_size = os.fstat(file.fileno())[6]
272
223
        tail, ranges = self.parse_ranges(ranges_header_value)
273
224
        # Normalize tail into ranges
274
225
        if tail != 0:
295
246
            # RFC2616 14.16 and 14.35 says that when a server
296
247
            # encounters unsatisfiable range specifiers, it
297
248
            # SHOULD return a 416.
298
 
            f.close()
 
249
            file.close()
299
250
            # FIXME: We SHOULD send a Content-Range header too,
300
251
            # but the implementation of send_error does not
301
252
            # allows that. So far.
304
255
 
305
256
        if len(ranges) == 1:
306
257
            (start, end) = ranges[0]
307
 
            self.get_single_range(f, file_size, start, end)
 
258
            self.get_single_range(file, file_size, start, end)
308
259
        else:
309
 
            self.get_multiple_ranges(f, file_size, ranges)
310
 
        f.close()
 
260
            self.get_multiple_ranges(file, file_size, ranges)
 
261
        file.close()
311
262
 
312
263
    def translate_path(self, path):
313
264
        """Translate a /-separated PATH to the local filename syntax.
333
284
        return self._translate_path(path)
334
285
 
335
286
    def _translate_path(self, path):
336
 
        """Translate a /-separated PATH to the local filename syntax.
337
 
 
338
 
        Note that we're translating http URLs here, not file URLs.
339
 
        The URL root location is the server's startup directory.
340
 
        Components that mean special things to the local file system
341
 
        (e.g. drive or directory names) are ignored.  (XXX They should
342
 
        probably be diagnosed.)
343
 
 
344
 
        Override from python standard library to stop it calling os.getcwd()
345
 
        """
346
 
        # abandon query parameters
347
 
        path = urlparse.urlparse(path)[2]
348
 
        path = posixpath.normpath(urllib.unquote(path))
349
 
        path = path.decode('utf-8')
350
 
        words = path.split('/')
351
 
        words = filter(None, words)
352
 
        path = self._cwd
353
 
        for num, word in enumerate(words):
354
 
            if num == 0:
 
287
        return SimpleHTTPServer.SimpleHTTPRequestHandler.translate_path(
 
288
            self, path)
 
289
 
 
290
    if sys.platform == 'win32':
 
291
        # On win32 you cannot access non-ascii filenames without
 
292
        # decoding them into unicode first.
 
293
        # However, under Linux, you can access bytestream paths
 
294
        # without any problems. If this function was always active
 
295
        # it would probably break tests when LANG=C was set
 
296
        def _translate_path(self, path):
 
297
            """Translate a /-separated PATH to the local filename syntax.
 
298
 
 
299
            For bzr, all url paths are considered to be utf8 paths.
 
300
            On Linux, you can access these paths directly over the bytestream
 
301
            request, but on win32, you must decode them, and access them
 
302
            as Unicode files.
 
303
            """
 
304
            # abandon query parameters
 
305
            path = urlparse.urlparse(path)[2]
 
306
            path = posixpath.normpath(urllib.unquote(path))
 
307
            path = path.decode('utf-8')
 
308
            words = path.split('/')
 
309
            words = filter(None, words)
 
310
            path = os.getcwdu()
 
311
            for word in words:
355
312
                drive, word = os.path.splitdrive(word)
356
 
            head, word = os.path.split(word)
357
 
            if word in (os.curdir, os.pardir): continue
358
 
            path = os.path.join(path, word)
359
 
        return path
 
313
                head, word = os.path.split(word)
 
314
                if word in (os.curdir, os.pardir): continue
 
315
                path = os.path.join(path, word)
 
316
            return path
360
317
 
361
318
 
362
319
class TestingHTTPServerMixin:
367
324
        # server), allowing dynamic behaviors to be defined from
368
325
        # the tests cases.
369
326
        self.test_case_server = test_case_server
370
 
        self._home_dir = test_case_server._home_dir
371
 
 
372
 
 
373
 
class TestingHTTPServer(test_server.TestingTCPServer, TestingHTTPServerMixin):
 
327
 
 
328
    def tearDown(self):
 
329
         """Called to clean-up the server.
 
330
 
 
331
         Since the server may be (surely is, even) in a blocking listen, we
 
332
         shutdown its socket before closing it.
 
333
         """
 
334
         # Note that is this executed as part of the implicit tear down in the
 
335
         # main thread while the server runs in its own thread. The clean way
 
336
         # to tear down the server is to instruct him to stop accepting
 
337
         # connections and wait for the current connection(s) to end
 
338
         # naturally. To end the connection naturally, the http transports
 
339
         # should close their socket when they do not need to talk to the
 
340
         # server anymore. This happens naturally during the garbage collection
 
341
         # phase of the test transport objetcs (the server clients), so we
 
342
         # don't have to worry about them.  So, for the server, we must tear
 
343
         # down here, from the main thread, when the test have ended.  Note
 
344
         # that since the server is in a blocking operation and since python
 
345
         # use select internally, shutting down the socket is reliable and
 
346
         # relatively clean.
 
347
         try:
 
348
             self.socket.shutdown(socket.SHUT_RDWR)
 
349
         except socket.error, e:
 
350
             # WSAENOTCONN (10057) 'Socket is not connected' is harmless on
 
351
             # windows (occurs before the first connection attempt
 
352
             # vila--20071230)
 
353
             if not len(e.args) or e.args[0] != 10057:
 
354
                 raise
 
355
         # Let the server properly close the socket
 
356
         self.server_close()
 
357
 
 
358
class TestingHTTPServer(SocketServer.TCPServer, TestingHTTPServerMixin):
374
359
 
375
360
    def __init__(self, server_address, request_handler_class,
376
361
                 test_case_server):
377
 
        test_server.TestingTCPServer.__init__(self, server_address,
378
 
                                              request_handler_class)
379
362
        TestingHTTPServerMixin.__init__(self, test_case_server)
380
 
 
381
 
 
382
 
class TestingThreadingHTTPServer(test_server.TestingThreadingTCPServer,
 
363
        SocketServer.TCPServer.__init__(self, server_address,
 
364
                                        request_handler_class)
 
365
 
 
366
 
 
367
class TestingThreadingHTTPServer(SocketServer.ThreadingTCPServer,
383
368
                                 TestingHTTPServerMixin):
384
369
    """A threading HTTP test server for HTTP 1.1.
385
370
 
387
372
    server, we need an independent connection for each of them. We achieve that
388
373
    by spawning a new thread for each connection.
389
374
    """
 
375
 
390
376
    def __init__(self, server_address, request_handler_class,
391
377
                 test_case_server):
392
 
        test_server.TestingThreadingTCPServer.__init__(self, server_address,
393
 
                                                       request_handler_class)
394
378
        TestingHTTPServerMixin.__init__(self, test_case_server)
395
 
 
396
 
 
397
 
class HttpServer(test_server.TestingTCPServerInAThread):
 
379
        SocketServer.ThreadingTCPServer.__init__(self, server_address,
 
380
                                                 request_handler_class)
 
381
        # Decides how threads will act upon termination of the main
 
382
        # process. This is prophylactic as we should not leave the threads
 
383
        # lying around.
 
384
        self.daemon_threads = True
 
385
 
 
386
 
 
387
class HttpServer(transport.Server):
398
388
    """A test server for http transports.
399
389
 
400
390
    Subclasses can provide a specific request handler.
422
412
        :param protocol_version: if specified, will override the protocol
423
413
            version of the request handler.
424
414
        """
425
 
        # Depending on the protocol version, we will create the approriate
426
 
        # server
427
 
        if protocol_version is None:
428
 
            # Use the request handler one
429
 
            proto_vers = request_handler.protocol_version
430
 
        else:
431
 
            # Use our own, it will be used to override the request handler
432
 
            # one too.
433
 
            proto_vers = protocol_version
434
 
        # Get the appropriate server class for the required protocol
435
 
        serv_cls = self.http_server_class.get(proto_vers, None)
436
 
        if serv_cls is None:
437
 
            raise httplib.UnknownProtocol(proto_vers)
 
415
        transport.Server.__init__(self)
 
416
        self.request_handler = request_handler
438
417
        self.host = 'localhost'
439
418
        self.port = 0
440
 
        super(HttpServer, self).__init__((self.host, self.port),
441
 
                                         serv_cls,
442
 
                                         request_handler)
443
 
        self.protocol_version = proto_vers
 
419
        self._httpd = None
 
420
        self.protocol_version = protocol_version
444
421
        # Allows tests to verify number of GET requests issued
445
422
        self.GET_request_nb = 0
446
 
        self._http_base_url = None
447
 
        self.logs = []
448
 
 
449
 
    def create_server(self):
450
 
        return self.server_class(
451
 
            (self.host, self.port), self.request_handler_class, self)
 
423
 
 
424
    def _get_httpd(self):
 
425
        if self._httpd is None:
 
426
            rhandler = self.request_handler
 
427
            # Depending on the protocol version, we will create the approriate
 
428
            # server
 
429
            if self.protocol_version is None:
 
430
                # Use the request handler one
 
431
                proto_vers = rhandler.protocol_version
 
432
            else:
 
433
                # Use our own, it will be used to override the request handler
 
434
                # one too.
 
435
                proto_vers = self.protocol_version
 
436
            # Create the appropriate server for the required protocol
 
437
            serv_cls = self.http_server_class.get(proto_vers, None)
 
438
            if serv_cls is None:
 
439
                raise httplib.UnknownProtocol(proto_vers)
 
440
            else:
 
441
                self._httpd = serv_cls((self.host, self.port), rhandler, self)
 
442
            host, self.port = self._httpd.socket.getsockname()
 
443
        return self._httpd
 
444
 
 
445
    def _http_start(self):
 
446
        """Server thread main entry point. """
 
447
        self._http_running = False
 
448
        try:
 
449
            try:
 
450
                httpd = self._get_httpd()
 
451
                self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
 
452
                                                       self.host, self.port)
 
453
                self._http_running = True
 
454
            except:
 
455
                # Whatever goes wrong, we save the exception for the main
 
456
                # thread. Note that since we are running in a thread, no signal
 
457
                # can be received, so we don't care about KeyboardInterrupt.
 
458
                self._http_exception = sys.exc_info()
 
459
        finally:
 
460
            # Release the lock or the main thread will block and the whole
 
461
            # process will hang.
 
462
            self._http_starting.release()
 
463
 
 
464
        # From now on, exceptions are taken care of by the
 
465
        # SocketServer.BaseServer or the request handler.
 
466
        while self._http_running:
 
467
            try:
 
468
                # Really an HTTP connection but the python framework is generic
 
469
                # and call them requests
 
470
                httpd.handle_request()
 
471
            except socket.timeout:
 
472
                pass
452
473
 
453
474
    def _get_remote_url(self, path):
454
475
        path_parts = path.split(os.path.sep)
466
487
        """Capture Server log output."""
467
488
        self.logs.append(format % args)
468
489
 
469
 
    def start_server(self, backing_transport_server=None):
470
 
        """See bzrlib.transport.Server.start_server.
471
 
 
 
490
    def setUp(self, backing_transport_server=None):
 
491
        """See bzrlib.transport.Server.setUp.
 
492
        
472
493
        :param backing_transport_server: The transport that requests over this
473
494
            protocol should be forwarded to. Note that this is currently not
474
495
            supported for HTTP.
475
496
        """
476
497
        # XXX: TODO: make the server back onto vfs_server rather than local
477
498
        # disk.
478
 
        if not (backing_transport_server is None
479
 
                or isinstance(backing_transport_server,
480
 
                              test_server.LocalURLServer)):
481
 
            raise AssertionError(
482
 
                "HTTPServer currently assumes local transport, got %s" %
483
 
                backing_transport_server)
 
499
        assert backing_transport_server is None or \
 
500
            isinstance(backing_transport_server, local.LocalURLServer), \
 
501
            "HTTPServer currently assumes local transport, got %s" % \
 
502
            backing_transport_server
484
503
        self._home_dir = os.getcwdu()
485
504
        self._local_path_parts = self._home_dir.split(os.path.sep)
 
505
        self._http_base_url = None
 
506
 
 
507
        # Create the server thread
 
508
        self._http_starting = threading.Lock()
 
509
        self._http_starting.acquire()
 
510
        self._http_thread = threading.Thread(target=self._http_start)
 
511
        self._http_thread.setDaemon(True)
 
512
        self._http_exception = None
 
513
        self._http_thread.start()
 
514
 
 
515
        # Wait for the server thread to start (i.e release the lock)
 
516
        self._http_starting.acquire()
 
517
 
 
518
        if self._http_exception is not None:
 
519
            # Something went wrong during server start
 
520
            exc_class, exc_value, exc_tb = self._http_exception
 
521
            raise exc_class, exc_value, exc_tb
 
522
        self._http_starting.release()
486
523
        self.logs = []
487
524
 
488
 
        super(HttpServer, self).start_server()
489
 
        self._http_base_url = '%s://%s:%s/' % (
490
 
            self._url_protocol, self.host, self.port)
 
525
    def tearDown(self):
 
526
        """See bzrlib.transport.Server.tearDown."""
 
527
        self._httpd.tearDown()
 
528
        self._http_running = False
 
529
        # We don't need to 'self._http_thread.join()' here since the thread is
 
530
        # a daemonic one and will be garbage collected anyway. Joining just
 
531
        # slows us down for no added benefit.
491
532
 
492
533
    def get_url(self):
493
534
        """See bzrlib.transport.Server.get_url."""