← 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: John Arbash Meinel
  • Date: 2011-01-12 01:01:53 UTC
  • mfrom: (5597 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5599.
  • Revision ID: john@arbash-meinel.com-20110112010153-op19823r9e6hy7u6
Merge bzr.dev 5597 to resolve NEWS, aka bzr-2.3.txt

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-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
20
20
import posixpath
21
21
import random
22
22
import re
23
 
import select
24
23
import SimpleHTTPServer
25
24
import socket
26
 
import SocketServer
27
 
import sys
28
 
import threading
29
 
import time
30
25
import urllib
31
26
import urlparse
32
27
 
33
 
from bzrlib import transport
34
28
from bzrlib.tests import test_server
35
 
from bzrlib.transport import local
36
29
 
37
30
 
38
31
class BadWebserverPath(ValueError):
71
64
                self.headers.get('referer', '-'),
72
65
                self.headers.get('user-agent', '-'))
73
66
 
 
67
    def handle(self):
 
68
        SimpleHTTPServer.SimpleHTTPRequestHandler.handle(self)
 
69
        # Some client (pycurl, I'm looking at you) are more picky than others
 
70
        # and require that the socket itself is closed
 
71
        # (SocketServer.StreamRequestHandler only close the two associated
 
72
        # 'makefile' objects)
 
73
        self.connection.close()
 
74
 
74
75
    def handle_one_request(self):
75
76
        """Handle a single HTTP request.
76
77
 
78
79
        connection early to avoid polluting the test results.
79
80
        """
80
81
        try:
81
 
            SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
 
82
            self._handle_one_request()
82
83
        except socket.error, e:
83
84
            # Any socket error should close the connection, but some errors are
84
85
            # due to the client closing early and we don't want to pollute test
89
90
                                     errno.ECONNABORTED, errno.EBADF)):
90
91
                raise
91
92
 
 
93
    error_content_type = 'text/plain'
 
94
    error_message_format = '''\
 
95
Error code: %(code)s.
 
96
Message: %(message)s.
 
97
'''
 
98
 
 
99
    def send_error(self, code, message=None):
 
100
        """Send and log an error reply.
 
101
 
 
102
        We redefine the python-provided version to be able to set a 
 
103
        ``Content-Length`` header as some http/1.1 clients complain otherwise
 
104
        (see bug #568421).
 
105
 
 
106
        :param code: The HTTP error code.
 
107
 
 
108
        :param message: The explanation of the error code, Defaults to a short
 
109
             entry.
 
110
        """
 
111
 
 
112
        if message is None:
 
113
            try:
 
114
                message = self.responses[code][0]
 
115
            except KeyError:
 
116
                message = '???'
 
117
        self.log_error("code %d, message %s", code, message)
 
118
        content = (self.error_message_format %
 
119
                   {'code': code, 'message': message})
 
120
        self.send_response(code, message)
 
121
        self.send_header("Content-Type", self.error_content_type)
 
122
        self.send_header("Content-Length", "%d" % len(content))
 
123
        self.send_header('Connection', 'close')
 
124
        self.end_headers()
 
125
        if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
 
126
            self.wfile.write(content)
 
127
 
 
128
    def _handle_one_request(self):
 
129
        SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
 
130
 
92
131
    _range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
93
132
    _tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
94
133
 
213
252
            # mode may cause newline translations, making the
214
253
            # actual size of the content transmitted *less* than
215
254
            # the content-length!
216
 
            file = open(path, 'rb')
 
255
            f = open(path, 'rb')
217
256
        except IOError:
218
257
            self.send_error(404, "File not found")
219
258
            return
220
259
 
221
 
        file_size = os.fstat(file.fileno())[6]
 
260
        file_size = os.fstat(f.fileno())[6]
222
261
        tail, ranges = self.parse_ranges(ranges_header_value)
223
262
        # Normalize tail into ranges
224
263
        if tail != 0:
245
284
            # RFC2616 14.16 and 14.35 says that when a server
246
285
            # encounters unsatisfiable range specifiers, it
247
286
            # SHOULD return a 416.
248
 
            file.close()
 
287
            f.close()
249
288
            # FIXME: We SHOULD send a Content-Range header too,
250
289
            # but the implementation of send_error does not
251
290
            # allows that. So far.
254
293
 
255
294
        if len(ranges) == 1:
256
295
            (start, end) = ranges[0]
257
 
            self.get_single_range(file, file_size, start, end)
 
296
            self.get_single_range(f, file_size, start, end)
258
297
        else:
259
 
            self.get_multiple_ranges(file, file_size, ranges)
260
 
        file.close()
 
298
            self.get_multiple_ranges(f, file_size, ranges)
 
299
        f.close()
261
300
 
262
301
    def translate_path(self, path):
263
302
        """Translate a /-separated PATH to the local filename syntax.
319
358
        self.test_case_server = test_case_server
320
359
        self._home_dir = test_case_server._home_dir
321
360
 
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):
 
361
 
 
362
class TestingHTTPServer(test_server.TestingTCPServer, TestingHTTPServerMixin):
359
363
 
360
364
    def __init__(self, server_address, request_handler_class,
361
365
                 test_case_server):
 
366
        test_server.TestingTCPServer.__init__(self, server_address,
 
367
                                              request_handler_class)
362
368
        TestingHTTPServerMixin.__init__(self, test_case_server)
363
 
        SocketServer.TCPServer.__init__(self, server_address,
364
 
                                        request_handler_class)
365
 
 
366
 
 
367
 
class TestingThreadingHTTPServer(SocketServer.ThreadingTCPServer,
 
369
 
 
370
 
 
371
class TestingThreadingHTTPServer(test_server.TestingThreadingTCPServer,
368
372
                                 TestingHTTPServerMixin):
369
373
    """A threading HTTP test server for HTTP 1.1.
370
374
 
372
376
    server, we need an independent connection for each of them. We achieve that
373
377
    by spawning a new thread for each connection.
374
378
    """
375
 
 
376
379
    def __init__(self, server_address, request_handler_class,
377
380
                 test_case_server):
 
381
        test_server.TestingThreadingTCPServer.__init__(self, server_address,
 
382
                                                       request_handler_class)
378
383
        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):
 
384
 
 
385
 
 
386
class HttpServer(test_server.TestingTCPServerInAThread):
405
387
    """A test server for http transports.
406
388
 
407
389
    Subclasses can provide a specific request handler.
429
411
        :param protocol_version: if specified, will override the protocol
430
412
            version of the request handler.
431
413
        """
432
 
        transport.Server.__init__(self)
433
 
        self.request_handler = request_handler
 
414
        # Depending on the protocol version, we will create the approriate
 
415
        # server
 
416
        if protocol_version is None:
 
417
            # Use the request handler one
 
418
            proto_vers = request_handler.protocol_version
 
419
        else:
 
420
            # Use our own, it will be used to override the request handler
 
421
            # one too.
 
422
            proto_vers = protocol_version
 
423
        # Get the appropriate server class for the required protocol
 
424
        serv_cls = self.http_server_class.get(proto_vers, None)
 
425
        if serv_cls is None:
 
426
            raise httplib.UnknownProtocol(proto_vers)
434
427
        self.host = 'localhost'
435
428
        self.port = 0
436
 
        self._httpd = None
437
 
        self.protocol_version = protocol_version
 
429
        super(HttpServer, self).__init__((self.host, self.port),
 
430
                                         serv_cls,
 
431
                                         request_handler)
 
432
        self.protocol_version = proto_vers
438
433
        # Allows tests to verify number of GET requests issued
439
434
        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
 
 
448
 
    def _get_httpd(self):
449
 
        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()
467
 
        return self._httpd
468
 
 
469
 
    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()
487
 
 
488
 
        # From now on, exceptions are taken care of by the
489
 
        # SocketServer.BaseServer or the request handler.
490
 
        while self._http_running:
491
 
            try:
492
 
                # Really an HTTP connection but the python framework is generic
493
 
                # and call them requests
494
 
                httpd.handle_request()
495
 
            except socket.timeout:
496
 
                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
 
435
        self._http_base_url = None
 
436
        self.logs = []
 
437
 
 
438
    def create_server(self):
 
439
        return self.server_class(
 
440
            (self.host, self.port), self.request_handler_class, self)
508
441
 
509
442
    def _get_remote_url(self, path):
510
443
        path_parts = path.split(os.path.sep)
535
468
                or isinstance(backing_transport_server,
536
469
                              test_server.LocalURLServer)):
537
470
            raise AssertionError(
538
 
                "HTTPServer currently assumes local transport, got %s" % \
 
471
                "HTTPServer currently assumes local transport, got %s" %
539
472
                backing_transport_server)
540
473
        self._home_dir = os.getcwdu()
541
474
        self._local_path_parts = self._home_dir.split(os.path.sep)
542
 
        self._http_base_url = None
543
 
 
544
 
        # Create the server thread
545
 
        self._http_starting = threading.Lock()
546
 
        self._http_starting.acquire()
547
 
        self._http_thread = threading.Thread(target=self._http_start)
548
 
        self._http_thread.setDaemon(True)
549
 
        self._http_exception = None
550
 
        self._http_thread.start()
551
 
 
552
 
        # Wait for the server thread to start (i.e release the lock)
553
 
        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
 
        self._http_starting.release()
560
475
        self.logs = []
561
476
 
562
 
    def stop_server(self):
563
 
        self._httpd.stop_server()
564
 
        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.
 
477
        super(HttpServer, self).start_server()
 
478
        self._http_base_url = '%s://%s:%s/' % (
 
479
            self._url_protocol, self.host, self.port)
568
480
 
569
481
    def get_url(self):
570
482
        """See bzrlib.transport.Server.get_url."""