← 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: Vincent Ladeuil
  • Date: 2007-11-24 14:20:59 UTC
  • mto: (3928.1.1 bzr.integration)
  • mto: This revision was merged to the branch mainline in revision 3929.
  • Revision ID: v.ladeuil+lp@free.fr-20071124142059-2114qtsgfdv8g9p1
Ssl files needed for the test https server.

* bzrlib/tests/ssl_certs/create_ssls.py: 
Script to create the ssl keys and certificates.

* bzrlib/tests/ssl_certs/server.crt: 
Server certificate signed by the certificate authority.

* bzrlib/tests/ssl_certs/server.csr: 
Server certificate signing request.

* bzrlib/tests/ssl_certs/server_without_pass.key: 
Server key usable without password.

* bzrlib/tests/ssl_certs/server_with_pass.key: 
Server key.

* bzrlib/tests/ssl_certs/ca.key: 
Certificate authority private key.

* bzrlib/tests/ssl_certs/ca.crt: 
Certificate authority certificate.

* bzrlib/tests/ssl_certs/__init__.py: 
Provide access to ssl files (keys and certificates). 

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
 
import httplib
19
19
import os
 
20
from SimpleHTTPServer import SimpleHTTPRequestHandler
 
21
import socket
20
22
import posixpath
21
23
import random
22
24
import re
23
 
import select
24
 
import SimpleHTTPServer
25
 
import socket
26
 
import SocketServer
27
25
import sys
28
26
import threading
29
27
import time
30
28
import urllib
31
29
import urlparse
32
30
 
33
 
from bzrlib import transport
34
 
from bzrlib.tests import test_server
35
 
from bzrlib.transport import local
 
31
from bzrlib.transport import Server
 
32
from bzrlib.transport.local import LocalURLServer
36
33
 
37
34
 
38
35
class BadWebserverPath(ValueError):
40
37
        return 'path %s is not in %s' % self.args
41
38
 
42
39
 
43
 
class TestingHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
 
40
class TestingHTTPRequestHandler(SimpleHTTPRequestHandler):
44
41
    """Handles one request.
45
42
 
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.
 
43
    A TestingHTTPRequestHandler is instantiated for every request
 
44
    received by the associated server.
50
45
    """
51
 
    # Default protocol version
52
 
    protocol_version = 'HTTP/1.1'
53
 
 
54
 
    # The Message-like class used to parse the request headers
55
 
    MessageClass = httplib.HTTPMessage
56
 
 
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
46
 
65
47
    def log_message(self, format, *args):
66
48
        tcs = self.server.test_case_server
78
60
        connection early to avoid polluting the test results.
79
61
        """
80
62
        try:
81
 
            SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
 
63
            SimpleHTTPRequestHandler.handle_one_request(self)
82
64
        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)):
 
65
            if (len(e.args) > 0
 
66
                and e.args[0] in (errno.EPIPE, errno.ECONNRESET,
 
67
                                  errno.ECONNABORTED,)):
 
68
                self.close_connection = 1
 
69
                pass
 
70
            else:
90
71
                raise
91
72
 
92
73
    _range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
125
106
                    return 0, []
126
107
        return tail, ranges
127
108
 
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
109
    def send_range_content(self, file, start, length):
149
110
        file.seek(start)
150
111
        self.wfile.write(file.read(length))
165
126
    def get_multiple_ranges(self, file, file_size, ranges):
166
127
        self.send_response(206)
167
128
        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)
 
129
        boundary = "%d" % random.randint(0,0x7FFFFFFF)
 
130
        self.send_header("Content-Type",
 
131
                         "multipart/byteranges; boundary=%s" % boundary)
184
132
        self.end_headers()
185
 
 
186
 
        # Send the multipart body
187
133
        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))
 
134
            self.wfile.write("--%s\r\n" % boundary)
 
135
            self.send_header("Content-type", 'application/octet-stream')
 
136
            self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
 
137
                                                                  end,
 
138
                                                                  file_size))
192
139
            self.end_headers()
193
140
            self.send_range_content(file, start, end - start + 1)
194
 
        # Final boundary
195
 
        self.wfile.write(boundary_line)
 
141
            self.wfile.write("--%s\r\n" % boundary)
196
142
 
197
143
    def do_GET(self):
198
144
        """Serve a GET request.
199
145
 
200
146
        Handles the Range header.
201
147
        """
202
 
        # Update statistics
203
 
        self.server.test_case_server.GET_request_nb += 1
204
148
 
205
149
        path = self.translate_path(self.path)
206
150
        ranges_header_value = self.headers.get('Range')
207
151
        if ranges_header_value is None or os.path.isdir(path):
208
152
            # Let the mother class handle most cases
209
 
            return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
 
153
            return SimpleHTTPRequestHandler.do_GET(self)
210
154
 
211
155
        try:
212
156
            # Always read in binary mode. Opening files in text
283
227
        return self._translate_path(path)
284
228
 
285
229
    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:
 
230
        return SimpleHTTPRequestHandler.translate_path(self, path)
 
231
 
 
232
    if sys.platform == 'win32':
 
233
        # On win32 you cannot access non-ascii filenames without
 
234
        # decoding them into unicode first.
 
235
        # However, under Linux, you can access bytestream paths
 
236
        # without any problems. If this function was always active
 
237
        # it would probably break tests when LANG=C was set
 
238
        def _translate_path(self, path):
 
239
            """Translate a /-separated PATH to the local filename syntax.
 
240
 
 
241
            For bzr, all url paths are considered to be utf8 paths.
 
242
            On Linux, you can access these paths directly over the bytestream
 
243
            request, but on win32, you must decode them, and access them
 
244
            as Unicode files.
 
245
            """
 
246
            # abandon query parameters
 
247
            path = urlparse.urlparse(path)[2]
 
248
            path = posixpath.normpath(urllib.unquote(path))
 
249
            path = path.decode('utf-8')
 
250
            words = path.split('/')
 
251
            words = filter(None, words)
 
252
            path = os.getcwdu()
 
253
            for word in words:
305
254
                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):
 
255
                head, word = os.path.split(word)
 
256
                if word in (os.curdir, os.pardir): continue
 
257
                path = os.path.join(path, word)
 
258
            return path
 
259
 
 
260
 
 
261
class TestingHTTPServer(BaseHTTPServer.HTTPServer):
 
262
 
 
263
    def __init__(self, server_address, request_handler_class,
 
264
                 test_case_server):
 
265
        BaseHTTPServer.HTTPServer.__init__(self, server_address,
 
266
                                           request_handler_class)
315
267
        # test_case_server can be used to communicate between the
316
268
        # tests and the server (or the request handler and the
317
269
        # server), allowing dynamic behaviors to be defined from
318
270
        # the tests cases.
319
271
        self.test_case_server = test_case_server
320
 
        self._home_dir = test_case_server._home_dir
321
 
 
322
 
    def stop_server(self):
323
 
         """Called to clean-up the server.
324
 
 
325
 
         Since the server may be (surely is, even) in a blocking listen, we
326
 
         shutdown its socket before closing it.
327
 
         """
328
 
         # Note that is this executed as part of the implicit tear down in the
329
 
         # 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
354
 
         # 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):
369
 
    """A threading HTTP test server for HTTP 1.1.
370
 
 
371
 
    Since tests can initiate several concurrent connections to the same http
372
 
    server, we need an independent connection for each of them. We achieve that
373
 
    by spawning a new thread for each connection.
374
 
    """
375
 
 
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)
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
 
    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
402
 
 
403
 
 
404
 
class HttpServer(transport.Server):
 
272
 
 
273
    def server_close(self):
 
274
        """Called to clean-up the server.
 
275
 
 
276
        Since the server may be in a blocking read, we shutdown the socket
 
277
        before closing it.
 
278
        """
 
279
        self.socket.shutdown(socket.SHUT_RDWR)
 
280
        BaseHTTPServer.HTTPServer.server_close(self)
 
281
 
 
282
 
 
283
class HttpServer(Server):
405
284
    """A test server for http transports.
406
285
 
407
286
    Subclasses can provide a specific request handler.
408
287
    """
409
288
 
410
 
    # The real servers depending on the protocol
411
 
    http_server_class = {'HTTP/1.0': TestingHTTPServer,
412
 
                         'HTTP/1.1': TestingThreadingHTTPServer,
413
 
                         }
414
 
 
415
289
    # Whether or not we proxy the requests (see
416
290
    # TestingHTTPRequestHandler.translate_path).
417
291
    proxy_requests = False
419
293
    # used to form the url that connects to this server
420
294
    _url_protocol = 'http'
421
295
 
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
 
        """
432
 
        transport.Server.__init__(self)
 
296
    # Subclasses can provide a specific request handler
 
297
    def __init__(self, request_handler=TestingHTTPRequestHandler):
 
298
        Server.__init__(self)
433
299
        self.request_handler = request_handler
434
300
        self.host = 'localhost'
435
301
        self.port = 0
436
302
        self._httpd = None
437
 
        self.protocol_version = protocol_version
438
 
        # Allows tests to verify number of GET requests issued
439
 
        self.GET_request_nb = 0
440
 
 
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
303
 
448
304
    def _get_httpd(self):
449
305
        if self._httpd is None:
450
 
            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
460
 
            # Create the appropriate server for the required protocol
461
 
            serv_cls = self.http_server_class.get(proto_vers, None)
462
 
            if serv_cls is None:
463
 
                raise httplib.UnknownProtocol(proto_vers)
464
 
            else:
465
 
                self._httpd = self.create_httpd(serv_cls, rhandler)
466
 
            self.host, self.port = self._httpd.socket.getsockname()
 
306
            self._httpd = TestingHTTPServer((self.host, self.port),
 
307
                                            self.request_handler,
 
308
                                            self)
 
309
            host, self.port = self._httpd.socket.getsockname()
467
310
        return self._httpd
468
311
 
469
312
    def _http_start(self):
470
 
        """Server thread main entry point. """
471
 
        self._http_running = False
472
 
        try:
473
 
            try:
474
 
                httpd = self._get_httpd()
475
 
                self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
476
 
                                                       self.host, self.port)
477
 
                self._http_running = True
478
 
            except:
479
 
                # Whatever goes wrong, we save the exception for the main
480
 
                # thread. Note that since we are running in a thread, no signal
481
 
                # can be received, so we don't care about KeyboardInterrupt.
482
 
                self._http_exception = sys.exc_info()
483
 
        finally:
484
 
            # Release the lock or the main thread will block and the whole
485
 
            # process will hang.
486
 
            self._http_starting.release()
 
313
        httpd = self._get_httpd()
 
314
        self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
 
315
                                               self.host,
 
316
                                               self.port)
 
317
        self._http_starting.release()
487
318
 
488
 
        # From now on, exceptions are taken care of by the
489
 
        # SocketServer.BaseServer or the request handler.
490
319
        while self._http_running:
491
320
            try:
492
 
                # Really an HTTP connection but the python framework is generic
493
 
                # and call them requests
494
321
                httpd.handle_request()
495
322
            except socket.timeout:
496
323
                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
324
 
509
325
    def _get_remote_url(self, path):
510
326
        path_parts = path.split(os.path.sep)
522
338
        """Capture Server log output."""
523
339
        self.logs.append(format % args)
524
340
 
525
 
    def start_server(self, backing_transport_server=None):
526
 
        """See bzrlib.transport.Server.start_server.
527
 
 
 
341
    def setUp(self, backing_transport_server=None):
 
342
        """See bzrlib.transport.Server.setUp.
 
343
        
528
344
        :param backing_transport_server: The transport that requests over this
529
345
            protocol should be forwarded to. Note that this is currently not
530
346
            supported for HTTP.
531
347
        """
532
348
        # XXX: TODO: make the server back onto vfs_server rather than local
533
349
        # 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)
 
350
        assert backing_transport_server is None or \
 
351
            isinstance(backing_transport_server, LocalURLServer), \
 
352
            "HTTPServer currently assumes local transport, got %s" % \
 
353
            backing_transport_server
540
354
        self._home_dir = os.getcwdu()
541
355
        self._local_path_parts = self._home_dir.split(os.path.sep)
 
356
        self._http_starting = threading.Lock()
 
357
        self._http_starting.acquire()
 
358
        self._http_running = True
542
359
        self._http_base_url = None
543
 
 
544
 
        # Create the server thread
545
 
        self._http_starting = threading.Lock()
546
 
        self._http_starting.acquire()
547
360
        self._http_thread = threading.Thread(target=self._http_start)
548
361
        self._http_thread.setDaemon(True)
549
 
        self._http_exception = None
550
362
        self._http_thread.start()
551
 
 
552
363
        # Wait for the server thread to start (i.e release the lock)
553
364
        self._http_starting.acquire()
554
 
 
555
 
        if self._http_exception is not None:
556
 
            # Something went wrong during server start
557
 
            exc_class, exc_value, exc_tb = self._http_exception
558
 
            raise exc_class, exc_value, exc_tb
559
365
        self._http_starting.release()
560
366
        self.logs = []
561
367
 
562
 
    def stop_server(self):
563
 
        self._httpd.stop_server()
 
368
    def tearDown(self):
 
369
        """See bzrlib.transport.Server.tearDown."""
 
370
        self._httpd.server_close()
564
371
        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.
 
372
        self._http_thread.join()
568
373
 
569
374
    def get_url(self):
570
375
        """See bzrlib.transport.Server.get_url."""