← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/HttpServer.py

  • Committer: Ian Clatworthy
  • Date: 2007-12-07 04:21:59 UTC
  • mto: This revision was merged to the branch mainline in revision 3092.
  • Revision ID: ian.clatworthy@internode.on.net-20071207042159-n9rmhanqid1l7olh
Better PDF for Qiock Start Card (Ian Clatworthy)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/HttpServer.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2006 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.transport import local
 
31
from bzrlib.transport import Server
 
32
from bzrlib.transport.local import LocalURLServer
 
33
 
 
34
 
 
35
class WebserverNotAvailable(Exception):
 
36
    pass
35
37
 
36
38
 
37
39
class BadWebserverPath(ValueError):
39
41
        return 'path %s is not in %s' % self.args
40
42
 
41
43
 
42
 
class TestingHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
 
44
class TestingHTTPRequestHandler(SimpleHTTPRequestHandler):
43
45
    """Handles one request.
44
46
 
45
 
    A TestingHTTPRequestHandler is instantiated for every request received by
46
 
    the associated server. Note that 'request' here is inherited from the base
47
 
    TCPServer class, for the HTTP server it is really a connection which itself
48
 
    will handle one or several HTTP requests.
 
47
    A TestingHTTPRequestHandler is instantiated for every request
 
48
    received by the associated server.
49
49
    """
50
 
    # Default protocol version
51
 
    protocol_version = 'HTTP/1.1'
52
 
 
53
 
    # The Message-like class used to parse the request headers
54
 
    MessageClass = httplib.HTTPMessage
55
 
 
56
 
    def setup(self):
57
 
        SimpleHTTPServer.SimpleHTTPRequestHandler.setup(self)
58
 
        self._cwd = self.server._home_dir
59
 
        tcs = self.server.test_case_server
60
 
        if tcs.protocol_version is not None:
61
 
            # If the test server forced a protocol version, use it
62
 
            self.protocol_version = tcs.protocol_version
63
50
 
64
51
    def log_message(self, format, *args):
65
52
        tcs = self.server.test_case_server
77
64
        connection early to avoid polluting the test results.
78
65
        """
79
66
        try:
80
 
            SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
 
67
            SimpleHTTPRequestHandler.handle_one_request(self)
81
68
        except socket.error, e:
82
 
            # Any socket error should close the connection, but some errors are
83
 
            # due to the client closing early and we don't want to pollute test
84
 
            # results, so we raise only the others.
85
 
            self.close_connection = 1
86
 
            if (len(e.args) == 0
87
 
                or e.args[0] not in (errno.EPIPE, errno.ECONNRESET,
88
 
                                     errno.ECONNABORTED, errno.EBADF)):
 
69
            if (len(e.args) > 0
 
70
                and e.args[0] in (errno.EPIPE, errno.ECONNRESET,
 
71
                                  errno.ECONNABORTED,)):
 
72
                self.close_connection = 1
 
73
                pass
 
74
            else:
89
75
                raise
90
76
 
91
77
    _range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
124
110
                    return 0, []
125
111
        return tail, ranges
126
112
 
127
 
    def _header_line_length(self, keyword, value):
128
 
        header_line = '%s: %s\r\n' % (keyword, value)
129
 
        return len(header_line)
130
 
 
131
 
    def send_head(self):
132
 
        """Overrides base implementation to work around a bug in python2.5."""
133
 
        path = self.translate_path(self.path)
134
 
        if os.path.isdir(path) and not self.path.endswith('/'):
135
 
            # redirect browser - doing basically what apache does when
136
 
            # DirectorySlash option is On which is quite common (braindead, but
137
 
            # common)
138
 
            self.send_response(301)
139
 
            self.send_header("Location", self.path + "/")
140
 
            # Indicates that the body is empty for HTTP/1.1 clients
141
 
            self.send_header('Content-Length', '0')
142
 
            self.end_headers()
143
 
            return None
144
 
 
145
 
        return SimpleHTTPServer.SimpleHTTPRequestHandler.send_head(self)
146
 
 
147
113
    def send_range_content(self, file, start, length):
148
114
        file.seek(start)
149
115
        self.wfile.write(file.read(length))
164
130
    def get_multiple_ranges(self, file, file_size, ranges):
165
131
        self.send_response(206)
166
132
        self.send_header('Accept-Ranges', 'bytes')
167
 
        boundary = '%d' % random.randint(0,0x7FFFFFFF)
168
 
        self.send_header('Content-Type',
169
 
                         'multipart/byteranges; boundary=%s' % boundary)
170
 
        boundary_line = '--%s\r\n' % boundary
171
 
        # Calculate the Content-Length
172
 
        content_length = 0
173
 
        for (start, end) in ranges:
174
 
            content_length += len(boundary_line)
175
 
            content_length += self._header_line_length(
176
 
                'Content-type', 'application/octet-stream')
177
 
            content_length += self._header_line_length(
178
 
                'Content-Range', 'bytes %d-%d/%d' % (start, end, file_size))
179
 
            content_length += len('\r\n') # end headers
180
 
            content_length += end - start + 1
181
 
        content_length += len(boundary_line)
182
 
        self.send_header('Content-length', content_length)
 
133
        boundary = "%d" % random.randint(0,0x7FFFFFFF)
 
134
        self.send_header("Content-Type",
 
135
                         "multipart/byteranges; boundary=%s" % boundary)
183
136
        self.end_headers()
184
 
 
185
 
        # Send the multipart body
186
137
        for (start, end) in ranges:
187
 
            self.wfile.write(boundary_line)
188
 
            self.send_header('Content-type', 'application/octet-stream')
189
 
            self.send_header('Content-Range', 'bytes %d-%d/%d'
190
 
                             % (start, end, file_size))
 
138
            self.wfile.write("--%s\r\n" % boundary)
 
139
            self.send_header("Content-type", 'application/octet-stream')
 
140
            self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
 
141
                                                                  end,
 
142
                                                                  file_size))
191
143
            self.end_headers()
192
144
            self.send_range_content(file, start, end - start + 1)
193
 
        # Final boundary
194
 
        self.wfile.write(boundary_line)
 
145
            self.wfile.write("--%s\r\n" % boundary)
195
146
 
196
147
    def do_GET(self):
197
148
        """Serve a GET request.
205
156
        ranges_header_value = self.headers.get('Range')
206
157
        if ranges_header_value is None or os.path.isdir(path):
207
158
            # Let the mother class handle most cases
208
 
            return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
 
159
            return SimpleHTTPRequestHandler.do_GET(self)
209
160
 
210
161
        try:
211
162
            # Always read in binary mode. Opening files in text
282
233
        return self._translate_path(path)
283
234
 
284
235
    def _translate_path(self, path):
285
 
        """Translate a /-separated PATH to the local filename syntax.
286
 
 
287
 
        Note that we're translating http URLs here, not file URLs.
288
 
        The URL root location is the server's startup directory.
289
 
        Components that mean special things to the local file system
290
 
        (e.g. drive or directory names) are ignored.  (XXX They should
291
 
        probably be diagnosed.)
292
 
 
293
 
        Override from python standard library to stop it calling os.getcwd()
294
 
        """
295
 
        # abandon query parameters
296
 
        path = urlparse.urlparse(path)[2]
297
 
        path = posixpath.normpath(urllib.unquote(path))
298
 
        path = path.decode('utf-8')
299
 
        words = path.split('/')
300
 
        words = filter(None, words)
301
 
        path = self._cwd
302
 
        for num, word in enumerate(words):
303
 
            if num == 0:
 
236
        return SimpleHTTPRequestHandler.translate_path(self, path)
 
237
 
 
238
    if sys.platform == 'win32':
 
239
        # On win32 you cannot access non-ascii filenames without
 
240
        # decoding them into unicode first.
 
241
        # However, under Linux, you can access bytestream paths
 
242
        # without any problems. If this function was always active
 
243
        # it would probably break tests when LANG=C was set
 
244
        def _translate_path(self, path):
 
245
            """Translate a /-separated PATH to the local filename syntax.
 
246
 
 
247
            For bzr, all url paths are considered to be utf8 paths.
 
248
            On Linux, you can access these paths directly over the bytestream
 
249
            request, but on win32, you must decode them, and access them
 
250
            as Unicode files.
 
251
            """
 
252
            # abandon query parameters
 
253
            path = urlparse.urlparse(path)[2]
 
254
            path = posixpath.normpath(urllib.unquote(path))
 
255
            path = path.decode('utf-8')
 
256
            words = path.split('/')
 
257
            words = filter(None, words)
 
258
            path = os.getcwdu()
 
259
            for word in words:
304
260
                drive, word = os.path.splitdrive(word)
305
 
            head, word = os.path.split(word)
306
 
            if word in (os.curdir, os.pardir): continue
307
 
            path = os.path.join(path, word)
308
 
        return path
309
 
 
310
 
 
311
 
class TestingHTTPServerMixin:
312
 
 
313
 
    def __init__(self, test_case_server):
 
261
                head, word = os.path.split(word)
 
262
                if word in (os.curdir, os.pardir): continue
 
263
                path = os.path.join(path, word)
 
264
            return path
 
265
 
 
266
 
 
267
class TestingHTTPServer(BaseHTTPServer.HTTPServer):
 
268
 
 
269
    def __init__(self, server_address, RequestHandlerClass,
 
270
                 test_case_server):
 
271
        BaseHTTPServer.HTTPServer.__init__(self, server_address,
 
272
                                           RequestHandlerClass)
314
273
        # test_case_server can be used to communicate between the
315
274
        # tests and the server (or the request handler and the
316
275
        # server), allowing dynamic behaviors to be defined from
317
276
        # the tests cases.
318
277
        self.test_case_server = test_case_server
319
 
        self._home_dir = test_case_server._home_dir
320
 
 
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):
358
 
 
359
 
    def __init__(self, server_address, request_handler_class,
360
 
                 test_case_server):
361
 
        TestingHTTPServerMixin.__init__(self, test_case_server)
362
 
        SocketServer.TCPServer.__init__(self, server_address,
363
 
                                        request_handler_class)
364
 
 
365
 
 
366
 
class TestingThreadingHTTPServer(SocketServer.ThreadingTCPServer,
367
 
                                 TestingHTTPServerMixin):
368
 
    """A threading HTTP test server for HTTP 1.1.
369
 
 
370
 
    Since tests can initiate several concurrent connections to the same http
371
 
    server, we need an independent connection for each of them. We achieve that
372
 
    by spawning a new thread for each connection.
373
 
    """
374
 
 
375
 
    def __init__(self, server_address, request_handler_class,
376
 
                 test_case_server):
377
 
        TestingHTTPServerMixin.__init__(self, test_case_server)
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
 
    def process_request_thread(self, request, client_address):
386
 
        SocketServer.ThreadingTCPServer.process_request_thread(
387
 
            self, request, client_address)
388
 
        # Under some circumstances (as in bug #383920), we need to force the
389
 
        # shutdown as python delays it until gc occur otherwise and the client
390
 
        # may hang.
391
 
        try:
392
 
            # The request process has been completed, the thread is about to
393
 
            # die, let's shutdown the socket if we can.
394
 
            request.shutdown(socket.SHUT_RDWR)
395
 
        except (socket.error, select.error), e:
396
 
            if e[0] in (errno.EBADF, errno.ENOTCONN):
397
 
                # Right, the socket is already down
398
 
                pass
399
 
            else:
400
 
                raise
401
 
 
402
 
 
403
 
class HttpServer(transport.Server):
 
278
 
 
279
    def server_close(self):
 
280
        """Called to clean-up the server.
 
281
 
 
282
        Since the server may be in a blocking read, we shutdown the socket
 
283
        before closing it.
 
284
        """
 
285
        self.socket.shutdown(socket.SHUT_RDWR)
 
286
        BaseHTTPServer.HTTPServer.server_close(self)
 
287
 
 
288
 
 
289
class HttpServer(Server):
404
290
    """A test server for http transports.
405
291
 
406
292
    Subclasses can provide a specific request handler.
407
293
    """
408
294
 
409
 
    # The real servers depending on the protocol
410
 
    http_server_class = {'HTTP/1.0': TestingHTTPServer,
411
 
                         'HTTP/1.1': TestingThreadingHTTPServer,
412
 
                         }
413
 
 
414
295
    # Whether or not we proxy the requests (see
415
296
    # TestingHTTPRequestHandler.translate_path).
416
297
    proxy_requests = False
418
299
    # used to form the url that connects to this server
419
300
    _url_protocol = 'http'
420
301
 
421
 
    def __init__(self, request_handler=TestingHTTPRequestHandler,
422
 
                 protocol_version=None):
423
 
        """Constructor.
424
 
 
425
 
        :param request_handler: a class that will be instantiated to handle an
426
 
            http connection (one or several requests).
427
 
 
428
 
        :param protocol_version: if specified, will override the protocol
429
 
            version of the request handler.
430
 
        """
431
 
        transport.Server.__init__(self)
 
302
    # Subclasses can provide a specific request handler
 
303
    def __init__(self, request_handler=TestingHTTPRequestHandler):
 
304
        Server.__init__(self)
432
305
        self.request_handler = request_handler
433
306
        self.host = 'localhost'
434
307
        self.port = 0
435
308
        self._httpd = None
436
 
        self.protocol_version = protocol_version
437
309
        # Allows tests to verify number of GET requests issued
438
310
        self.GET_request_nb = 0
439
311
 
440
 
    def create_httpd(self, serv_cls, rhandler_cls):
441
 
        return serv_cls((self.host, self.port), self.request_handler, self)
442
 
 
443
 
    def __repr__(self):
444
 
        return "%s(%s:%s)" % \
445
 
            (self.__class__.__name__, self.host, self.port)
446
 
 
447
312
    def _get_httpd(self):
448
313
        if self._httpd is None:
449
 
            rhandler = self.request_handler
450
 
            # Depending on the protocol version, we will create the approriate
451
 
            # server
452
 
            if self.protocol_version is None:
453
 
                # Use the request handler one
454
 
                proto_vers = rhandler.protocol_version
455
 
            else:
456
 
                # Use our own, it will be used to override the request handler
457
 
                # one too.
458
 
                proto_vers = self.protocol_version
459
 
            # Create the appropriate server for the required protocol
460
 
            serv_cls = self.http_server_class.get(proto_vers, None)
461
 
            if serv_cls is None:
462
 
                raise httplib.UnknownProtocol(proto_vers)
463
 
            else:
464
 
                self._httpd = self.create_httpd(serv_cls, rhandler)
 
314
            self._httpd = TestingHTTPServer((self.host, self.port),
 
315
                                            self.request_handler,
 
316
                                            self)
465
317
            host, self.port = self._httpd.socket.getsockname()
466
318
        return self._httpd
467
319
 
468
320
    def _http_start(self):
469
 
        """Server thread main entry point. """
470
 
        self._http_running = False
471
 
        try:
472
 
            try:
473
 
                httpd = self._get_httpd()
474
 
                self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
475
 
                                                       self.host, self.port)
476
 
                self._http_running = True
477
 
            except:
478
 
                # Whatever goes wrong, we save the exception for the main
479
 
                # thread. Note that since we are running in a thread, no signal
480
 
                # can be received, so we don't care about KeyboardInterrupt.
481
 
                self._http_exception = sys.exc_info()
482
 
        finally:
483
 
            # Release the lock or the main thread will block and the whole
484
 
            # process will hang.
485
 
            self._http_starting.release()
 
321
        httpd = self._get_httpd()
 
322
        self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
 
323
                                               self.host,
 
324
                                               self.port)
 
325
        self._http_starting.release()
486
326
 
487
 
        # From now on, exceptions are taken care of by the
488
 
        # SocketServer.BaseServer or the request handler.
489
327
        while self._http_running:
490
328
            try:
491
 
                # Really an HTTP connection but the python framework is generic
492
 
                # and call them requests
493
329
                httpd.handle_request()
494
330
            except socket.timeout:
495
331
                pass
496
 
            except (socket.error, select.error), e:
497
 
               if e[0] == errno.EBADF:
498
 
                   # Starting with python-2.6, handle_request may raise socket
499
 
                   # or select exceptions when the server is shut down (as we
500
 
                   # do).
501
 
                   pass
502
 
               else:
503
 
                   raise
504
332
 
505
333
    def _get_remote_url(self, path):
506
334
        path_parts = path.split(os.path.sep)
520
348
 
521
349
    def setUp(self, backing_transport_server=None):
522
350
        """See bzrlib.transport.Server.setUp.
523
 
 
 
351
        
524
352
        :param backing_transport_server: The transport that requests over this
525
353
            protocol should be forwarded to. Note that this is currently not
526
354
            supported for HTTP.
527
355
        """
528
356
        # XXX: TODO: make the server back onto vfs_server rather than local
529
357
        # disk.
530
 
        if not (backing_transport_server is None or \
531
 
                isinstance(backing_transport_server, local.LocalURLServer)):
532
 
            raise AssertionError(
533
 
                "HTTPServer currently assumes local transport, got %s" % \
534
 
                backing_transport_server)
 
358
        assert backing_transport_server is None or \
 
359
            isinstance(backing_transport_server, LocalURLServer), \
 
360
            "HTTPServer currently assumes local transport, got %s" % \
 
361
            backing_transport_server
535
362
        self._home_dir = os.getcwdu()
536
363
        self._local_path_parts = self._home_dir.split(os.path.sep)
 
364
        self._http_starting = threading.Lock()
 
365
        self._http_starting.acquire()
 
366
        self._http_running = True
537
367
        self._http_base_url = None
538
 
 
539
 
        # Create the server thread
540
 
        self._http_starting = threading.Lock()
541
 
        self._http_starting.acquire()
542
368
        self._http_thread = threading.Thread(target=self._http_start)
543
369
        self._http_thread.setDaemon(True)
544
 
        self._http_exception = None
545
370
        self._http_thread.start()
546
 
 
547
371
        # Wait for the server thread to start (i.e release the lock)
548
372
        self._http_starting.acquire()
549
 
 
550
 
        if self._http_exception is not None:
551
 
            # Something went wrong during server start
552
 
            exc_class, exc_value, exc_tb = self._http_exception
553
 
            raise exc_class, exc_value, exc_tb
554
373
        self._http_starting.release()
555
374
        self.logs = []
556
375
 
557
376
    def tearDown(self):
558
377
        """See bzrlib.transport.Server.tearDown."""
559
 
        self._httpd.tearDown()
 
378
        self._httpd.server_close()
560
379
        self._http_running = False
561
 
        # We don't need to 'self._http_thread.join()' here since the thread is
562
 
        # a daemonic one and will be garbage collected anyway. Joining just
563
 
        # slows us down for no added benefit.
 
380
        self._http_thread.join()
564
381
 
565
382
    def get_url(self):
566
383
        """See bzrlib.transport.Server.get_url."""
570
387
        """See bzrlib.transport.Server.get_bogus_url."""
571
388
        # this is chosen to try to prevent trouble with proxies, weird dns,
572
389
        # etc
573
 
        return self._url_protocol + '://127.0.0.1:1/'
 
390
        return 'http://127.0.0.1:1/'
574
391
 
575
392
 
576
393
class HttpServer_urllib(HttpServer):