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

Merge bzr.dev

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
import BaseHTTPServer
17
18
import errno
18
19
import httplib
19
20
import os
20
21
import posixpath
21
22
import random
22
23
import re
23
 
import select
24
24
import SimpleHTTPServer
25
25
import socket
26
26
import SocketServer
31
31
import urlparse
32
32
 
33
33
from bzrlib import transport
34
 
from bzrlib.tests import test_server
35
34
from bzrlib.transport import local
36
35
 
37
36
 
 
37
class WebserverNotAvailable(Exception):
 
38
    pass
 
39
 
 
40
 
38
41
class BadWebserverPath(ValueError):
39
42
    def __str__(self):
40
43
        return 'path %s is not in %s' % self.args
43
46
class TestingHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
44
47
    """Handles one request.
45
48
 
46
 
    A TestingHTTPRequestHandler is instantiated for every request received by
47
 
    the associated server. Note that 'request' here is inherited from the base
48
 
    TCPServer class, for the HTTP server it is really a connection which itself
49
 
    will handle one or several HTTP requests.
 
49
    A TestingHTTPRequestHandler is instantiated for every request
 
50
    received by the associated server.
50
51
    """
51
 
    # Default protocol version
52
 
    protocol_version = 'HTTP/1.1'
53
 
 
54
52
    # The Message-like class used to parse the request headers
55
53
    MessageClass = httplib.HTTPMessage
56
54
 
57
 
    def setup(self):
58
 
        SimpleHTTPServer.SimpleHTTPRequestHandler.setup(self)
59
 
        self._cwd = self.server._home_dir
60
 
        tcs = self.server.test_case_server
61
 
        if tcs.protocol_version is not None:
62
 
            # If the test server forced a protocol version, use it
63
 
            self.protocol_version = tcs.protocol_version
64
 
 
65
55
    def log_message(self, format, *args):
66
56
        tcs = self.server.test_case_server
67
57
        tcs.log('webserver - %s - - [%s] %s "%s" "%s"',
68
58
                self.address_string(),
69
59
                self.log_date_time_string(),
70
60
                format % args,
71
 
                self.headers.get('referer', '-'),
 
61
                self.headers.get('referrer', '-'),
72
62
                self.headers.get('user-agent', '-'))
73
63
 
74
64
    def handle_one_request(self):
80
70
        try:
81
71
            SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
82
72
        except socket.error, e:
83
 
            # Any socket error should close the connection, but some errors are
84
 
            # due to the client closing early and we don't want to pollute test
85
 
            # results, so we raise only the others.
86
 
            self.close_connection = 1
87
 
            if (len(e.args) == 0
88
 
                or e.args[0] not in (errno.EPIPE, errno.ECONNRESET,
89
 
                                     errno.ECONNABORTED, errno.EBADF)):
 
73
            if (len(e.args) > 0
 
74
                and e.args[0] in (errno.EPIPE, errno.ECONNRESET,
 
75
                                  errno.ECONNABORTED,)):
 
76
                self.close_connection = 1
 
77
            else:
90
78
                raise
91
79
 
92
80
    _range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
125
113
                    return 0, []
126
114
        return tail, ranges
127
115
 
128
 
    def _header_line_length(self, keyword, value):
129
 
        header_line = '%s: %s\r\n' % (keyword, value)
130
 
        return len(header_line)
131
 
 
132
 
    def send_head(self):
133
 
        """Overrides base implementation to work around a bug in python2.5."""
134
 
        path = self.translate_path(self.path)
135
 
        if os.path.isdir(path) and not self.path.endswith('/'):
136
 
            # redirect browser - doing basically what apache does when
137
 
            # DirectorySlash option is On which is quite common (braindead, but
138
 
            # common)
139
 
            self.send_response(301)
140
 
            self.send_header("Location", self.path + "/")
141
 
            # Indicates that the body is empty for HTTP/1.1 clients
142
 
            self.send_header('Content-Length', '0')
143
 
            self.end_headers()
144
 
            return None
145
 
 
146
 
        return SimpleHTTPServer.SimpleHTTPRequestHandler.send_head(self)
147
 
 
148
116
    def send_range_content(self, file, start, length):
149
117
        file.seek(start)
150
118
        self.wfile.write(file.read(length))
165
133
    def get_multiple_ranges(self, file, file_size, ranges):
166
134
        self.send_response(206)
167
135
        self.send_header('Accept-Ranges', 'bytes')
168
 
        boundary = '%d' % random.randint(0,0x7FFFFFFF)
169
 
        self.send_header('Content-Type',
170
 
                         'multipart/byteranges; boundary=%s' % boundary)
171
 
        boundary_line = '--%s\r\n' % boundary
172
 
        # Calculate the Content-Length
173
 
        content_length = 0
174
 
        for (start, end) in ranges:
175
 
            content_length += len(boundary_line)
176
 
            content_length += self._header_line_length(
177
 
                'Content-type', 'application/octet-stream')
178
 
            content_length += self._header_line_length(
179
 
                'Content-Range', 'bytes %d-%d/%d' % (start, end, file_size))
180
 
            content_length += len('\r\n') # end headers
181
 
            content_length += end - start + 1
182
 
        content_length += len(boundary_line)
183
 
        self.send_header('Content-length', content_length)
 
136
        boundary = "%d" % random.randint(0,0x7FFFFFFF)
 
137
        self.send_header("Content-Type",
 
138
                         "multipart/byteranges; boundary=%s" % boundary)
184
139
        self.end_headers()
185
 
 
186
 
        # Send the multipart body
187
140
        for (start, end) in ranges:
188
 
            self.wfile.write(boundary_line)
189
 
            self.send_header('Content-type', 'application/octet-stream')
190
 
            self.send_header('Content-Range', 'bytes %d-%d/%d'
191
 
                             % (start, end, file_size))
 
141
            self.wfile.write("--%s\r\n" % boundary)
 
142
            self.send_header("Content-type", 'application/octet-stream')
 
143
            self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
 
144
                                                                  end,
 
145
                                                                  file_size))
192
146
            self.end_headers()
193
147
            self.send_range_content(file, start, end - start + 1)
194
148
        # Final boundary
195
 
        self.wfile.write(boundary_line)
 
149
        self.wfile.write("--%s\r\n" % boundary)
196
150
 
197
151
    def do_GET(self):
198
152
        """Serve a GET request.
283
237
        return self._translate_path(path)
284
238
 
285
239
    def _translate_path(self, path):
286
 
        """Translate a /-separated PATH to the local filename syntax.
287
 
 
288
 
        Note that we're translating http URLs here, not file URLs.
289
 
        The URL root location is the server's startup directory.
290
 
        Components that mean special things to the local file system
291
 
        (e.g. drive or directory names) are ignored.  (XXX They should
292
 
        probably be diagnosed.)
293
 
 
294
 
        Override from python standard library to stop it calling os.getcwd()
295
 
        """
296
 
        # abandon query parameters
297
 
        path = urlparse.urlparse(path)[2]
298
 
        path = posixpath.normpath(urllib.unquote(path))
299
 
        path = path.decode('utf-8')
300
 
        words = path.split('/')
301
 
        words = filter(None, words)
302
 
        path = self._cwd
303
 
        for num, word in enumerate(words):
304
 
            if num == 0:
 
240
        return SimpleHTTPServer.SimpleHTTPRequestHandler.translate_path(
 
241
            self, path)
 
242
 
 
243
    if sys.platform == 'win32':
 
244
        # On win32 you cannot access non-ascii filenames without
 
245
        # decoding them into unicode first.
 
246
        # However, under Linux, you can access bytestream paths
 
247
        # without any problems. If this function was always active
 
248
        # it would probably break tests when LANG=C was set
 
249
        def _translate_path(self, path):
 
250
            """Translate a /-separated PATH to the local filename syntax.
 
251
 
 
252
            For bzr, all url paths are considered to be utf8 paths.
 
253
            On Linux, you can access these paths directly over the bytestream
 
254
            request, but on win32, you must decode them, and access them
 
255
            as Unicode files.
 
256
            """
 
257
            # abandon query parameters
 
258
            path = urlparse.urlparse(path)[2]
 
259
            path = posixpath.normpath(urllib.unquote(path))
 
260
            path = path.decode('utf-8')
 
261
            words = path.split('/')
 
262
            words = filter(None, words)
 
263
            path = os.getcwdu()
 
264
            for word in words:
305
265
                drive, word = os.path.splitdrive(word)
306
 
            head, word = os.path.split(word)
307
 
            if word in (os.curdir, os.pardir): continue
308
 
            path = os.path.join(path, word)
309
 
        return path
310
 
 
311
 
 
312
 
class TestingHTTPServerMixin:
313
 
 
314
 
    def __init__(self, test_case_server):
 
266
                head, word = os.path.split(word)
 
267
                if word in (os.curdir, os.pardir): continue
 
268
                path = os.path.join(path, word)
 
269
            return path
 
270
 
 
271
 
 
272
class TestingHTTPServerWrapper(object):
 
273
    """Isolate the wrapper itself to make the server use transparent.
 
274
 
 
275
    Daughter classes can override any method and/or directly call the _server
 
276
    methods.
 
277
    """
 
278
 
 
279
    def __init__(self, server_class, test_case_server,
 
280
                 server_address, request_handler_class):
 
281
        self._server = server_class(server_address, request_handler_class)
315
282
        # test_case_server can be used to communicate between the
316
283
        # tests and the server (or the request handler and the
317
284
        # server), allowing dynamic behaviors to be defined from
318
285
        # the tests cases.
319
 
        self.test_case_server = test_case_server
320
 
        self._home_dir = test_case_server._home_dir
321
 
 
322
 
    def stop_server(self):
 
286
        self._server.test_case_server = test_case_server
 
287
 
 
288
    def __getattr__(self, name):
 
289
        return getattr(self._server, name)
 
290
 
 
291
    def server_bind(self):
 
292
        """Override server_bind to store the server name."""
 
293
        self._server.server_bind()
 
294
        host, port = self._server.socket.getsockname()[:2]
 
295
        self._server.server_name = socket.getfqdn(host)
 
296
        self._server.server_port = port
 
297
 
 
298
    def server_close(self):
323
299
         """Called to clean-up the server.
324
 
 
 
300
 
325
301
         Since the server may be (surely is, even) in a blocking listen, we
326
302
         shutdown its socket before closing it.
327
303
         """
328
304
         # Note that is this executed as part of the implicit tear down in the
329
305
         # main thread while the server runs in its own thread. The clean way
330
 
         # to tear down the server is to instruct him to stop accepting
331
 
         # connections and wait for the current connection(s) to end
332
 
         # naturally. To end the connection naturally, the http transports
333
 
         # should close their socket when they do not need to talk to the
334
 
         # server anymore. This happens naturally during the garbage collection
335
 
         # phase of the test transport objetcs (the server clients), so we
336
 
         # don't have to worry about them.  So, for the server, we must tear
337
 
         # down here, from the main thread, when the test have ended.  Note
338
 
         # that since the server is in a blocking operation and since python
339
 
         # use select internally, shutting down the socket is reliable and
340
 
         # relatively clean.
341
 
         try:
342
 
             self.socket.shutdown(socket.SHUT_RDWR)
343
 
         except socket.error, e:
344
 
             # WSAENOTCONN (10057) 'Socket is not connected' is harmless on
345
 
             # windows (occurs before the first connection attempt
346
 
             # vila--20071230)
347
 
 
348
 
             # 'Socket is not connected' can also occur on OSX, with a
349
 
             # "regular" ENOTCONN (when something went wrong during test case
350
 
             # setup leading to self.setUp() *not* being called but
351
 
             # self.stop_server() still being called -- vila20081106
352
 
             if not len(e.args) or e.args[0] not in (errno.ENOTCONN, 10057):
353
 
                 raise
 
306
         # to tear down the server will be to instruct him to stop accepting
 
307
         # connections and wait for the current connection to end naturally. To
 
308
         # end the connection naturally, the http transports should close their
 
309
         # socket when they do not need to talk to the server anymore.  We
 
310
         # don't want to impose such a constraint on the http transports (and
 
311
         # we can't anyway ;). So we must tear down here, from the main thread,
 
312
         # when the test have ended.  Note that since the server is in a
 
313
         # blocking operation and since python use select internally, shutting
 
314
         # down the socket is reliable and relatively clean.
 
315
         self._server.socket.shutdown(socket.SHUT_RDWR)
354
316
         # Let the server properly close the socket
355
 
         self.server_close()
356
 
 
357
 
 
358
 
class TestingHTTPServer(SocketServer.TCPServer, TestingHTTPServerMixin):
359
 
 
360
 
    def __init__(self, server_address, request_handler_class,
361
 
                 test_case_server):
362
 
        TestingHTTPServerMixin.__init__(self, test_case_server)
363
 
        SocketServer.TCPServer.__init__(self, server_address,
364
 
                                        request_handler_class)
365
 
 
366
 
 
367
 
class TestingThreadingHTTPServer(SocketServer.ThreadingTCPServer,
368
 
                                 TestingHTTPServerMixin):
 
317
         self._server.server_close()
 
318
 
 
319
class TestingHTTPServer(TestingHTTPServerWrapper):
 
320
 
 
321
    def __init__(self, server_address, request_handler_class, test_case_server):
 
322
        super(TestingHTTPServer, self).__init__(
 
323
            SocketServer.TCPServer, test_case_server,
 
324
            server_address, request_handler_class)
 
325
 
 
326
 
 
327
class TestingThreadingHTTPServer(TestingHTTPServerWrapper):
369
328
    """A threading HTTP test server for HTTP 1.1.
370
329
 
371
330
    Since tests can initiate several concurrent connections to the same http
373
332
    by spawning a new thread for each connection.
374
333
    """
375
334
 
376
 
    def __init__(self, server_address, request_handler_class,
377
 
                 test_case_server):
378
 
        TestingHTTPServerMixin.__init__(self, test_case_server)
379
 
        SocketServer.ThreadingTCPServer.__init__(self, server_address,
380
 
                                                 request_handler_class)
 
335
    def __init__(self, server_address, request_handler_class, test_case_server):
 
336
        super(TestingThreadingHTTPServer, self).__init__(
 
337
            SocketServer.ThreadingTCPServer, test_case_server,
 
338
            server_address, request_handler_class)
381
339
        # Decides how threads will act upon termination of the main
382
340
        # process. This is prophylactic as we should not leave the threads
383
341
        # lying around.
384
 
        self.daemon_threads = True
385
 
 
386
 
    def process_request_thread(self, request, client_address):
387
 
        SocketServer.ThreadingTCPServer.process_request_thread(
388
 
            self, request, client_address)
389
 
        # Under some circumstances (as in bug #383920), we need to force the
390
 
        # shutdown as python delays it until gc occur otherwise and the client
391
 
        # may hang.
392
 
        try:
393
 
            # The request process has been completed, the thread is about to
394
 
            # die, let's shutdown the socket if we can.
395
 
            request.shutdown(socket.SHUT_RDWR)
396
 
        except (socket.error, select.error), e:
397
 
            if e[0] in (errno.EBADF, errno.ENOTCONN):
398
 
                # Right, the socket is already down
399
 
                pass
400
 
            else:
401
 
                raise
 
342
        self._server.daemon_threads = True
402
343
 
403
344
 
404
345
class HttpServer(transport.Server):
419
360
    # used to form the url that connects to this server
420
361
    _url_protocol = 'http'
421
362
 
422
 
    def __init__(self, request_handler=TestingHTTPRequestHandler,
423
 
                 protocol_version=None):
424
 
        """Constructor.
425
 
 
426
 
        :param request_handler: a class that will be instantiated to handle an
427
 
            http connection (one or several requests).
428
 
 
429
 
        :param protocol_version: if specified, will override the protocol
430
 
            version of the request handler.
431
 
        """
 
363
    # Subclasses can provide a specific request handler
 
364
    def __init__(self, request_handler=TestingHTTPRequestHandler):
432
365
        transport.Server.__init__(self)
433
366
        self.request_handler = request_handler
434
367
        self.host = 'localhost'
435
368
        self.port = 0
436
369
        self._httpd = None
437
 
        self.protocol_version = protocol_version
438
370
        # Allows tests to verify number of GET requests issued
439
371
        self.GET_request_nb = 0
440
372
 
441
 
    def create_httpd(self, serv_cls, rhandler_cls):
442
 
        return serv_cls((self.host, self.port), self.request_handler, self)
443
 
 
444
 
    def __repr__(self):
445
 
        return "%s(%s:%s)" % \
446
 
            (self.__class__.__name__, self.host, self.port)
447
 
 
448
373
    def _get_httpd(self):
449
374
        if self._httpd is None:
450
375
            rhandler = self.request_handler
451
 
            # Depending on the protocol version, we will create the approriate
452
 
            # server
453
 
            if self.protocol_version is None:
454
 
                # Use the request handler one
455
 
                proto_vers = rhandler.protocol_version
456
 
            else:
457
 
                # Use our own, it will be used to override the request handler
458
 
                # one too.
459
 
                proto_vers = self.protocol_version
 
376
            proto_vers = rhandler.protocol_version
460
377
            # Create the appropriate server for the required protocol
461
378
            serv_cls = self.http_server_class.get(proto_vers, None)
462
379
            if serv_cls is None:
463
380
                raise httplib.UnknownProtocol(proto_vers)
464
381
            else:
465
 
                self._httpd = self.create_httpd(serv_cls, rhandler)
466
 
            self.host, self.port = self._httpd.socket.getsockname()
 
382
                self._httpd = serv_cls((self.host, self.port), rhandler, self)
 
383
            host, self.port = self._httpd.socket.getsockname()
467
384
        return self._httpd
468
385
 
469
386
    def _http_start(self):
494
411
                httpd.handle_request()
495
412
            except socket.timeout:
496
413
                pass
497
 
            except (socket.error, select.error), e:
498
 
                if (e[0] == errno.EBADF
499
 
                    or (sys.platform == 'win32' and e[0] == 10038)):
500
 
                    # Starting with python-2.6, handle_request may raise socket
501
 
                    # or select exceptions when the server is shut down (as we
502
 
                    # do).
503
 
                    # 10038 = WSAENOTSOCK
504
 
                    # http://msdn.microsoft.com/en-us/library/ms740668%28VS.85%29.aspx
505
 
                    pass
506
 
                else:
507
 
                    raise
508
414
 
509
415
    def _get_remote_url(self, path):
510
416
        path_parts = path.split(os.path.sep)
522
428
        """Capture Server log output."""
523
429
        self.logs.append(format % args)
524
430
 
525
 
    def start_server(self, backing_transport_server=None):
526
 
        """See bzrlib.transport.Server.start_server.
527
 
 
 
431
    def setUp(self, backing_transport_server=None):
 
432
        """See bzrlib.transport.Server.setUp.
 
433
        
528
434
        :param backing_transport_server: The transport that requests over this
529
435
            protocol should be forwarded to. Note that this is currently not
530
436
            supported for HTTP.
531
437
        """
532
438
        # XXX: TODO: make the server back onto vfs_server rather than local
533
439
        # disk.
534
 
        if not (backing_transport_server is None
535
 
                or isinstance(backing_transport_server,
536
 
                              test_server.LocalURLServer)):
537
 
            raise AssertionError(
538
 
                "HTTPServer currently assumes local transport, got %s" % \
539
 
                backing_transport_server)
 
440
        assert backing_transport_server is None or \
 
441
            isinstance(backing_transport_server, local.LocalURLServer), \
 
442
            "HTTPServer currently assumes local transport, got %s" % \
 
443
            backing_transport_server
540
444
        self._home_dir = os.getcwdu()
541
445
        self._local_path_parts = self._home_dir.split(os.path.sep)
542
446
        self._http_base_url = None
553
457
        self._http_starting.acquire()
554
458
 
555
459
        if self._http_exception is not None:
556
 
            # Something went wrong during server start
557
460
            exc_class, exc_value, exc_tb = self._http_exception
558
461
            raise exc_class, exc_value, exc_tb
559
462
        self._http_starting.release()
560
463
        self.logs = []
561
464
 
562
 
    def stop_server(self):
563
 
        self._httpd.stop_server()
 
465
    def tearDown(self):
 
466
        """See bzrlib.transport.Server.tearDown."""
 
467
        self._httpd.server_close()
564
468
        self._http_running = False
565
 
        # We don't need to 'self._http_thread.join()' here since the thread is
566
 
        # a daemonic one and will be garbage collected anyway. Joining just
567
 
        # slows us down for no added benefit.
 
469
        self._http_thread.join()
568
470
 
569
471
    def get_url(self):
570
472
        """See bzrlib.transport.Server.get_url."""