← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/http_server.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/http_server.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
30
30
import urllib
31
31
import urlparse
32
32
 
33
 
from bzrlib import transport
 
33
from bzrlib import (
 
34
    osutils,
 
35
    tests,
 
36
    transport,
 
37
    )
 
38
from bzrlib.tests import test_server
34
39
from bzrlib.transport import local
35
40
 
36
41
 
70
75
                self.headers.get('referer', '-'),
71
76
                self.headers.get('user-agent', '-'))
72
77
 
 
78
    def handle(self):
 
79
        SimpleHTTPServer.SimpleHTTPRequestHandler.handle(self)
 
80
        # Some client (pycurl, I'm looking at you) are more picky than others
 
81
        # and require that the socket itself is closed
 
82
        # (SocketServer.StreamRequestHandler only close the two associated
 
83
        # 'makefile' objects)
 
84
        self.connection.close()
 
85
 
73
86
    def handle_one_request(self):
74
87
        """Handle a single HTTP request.
75
88
 
77
90
        connection early to avoid polluting the test results.
78
91
        """
79
92
        try:
80
 
            SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
 
93
            self._handle_one_request()
81
94
        except socket.error, e:
82
95
            # Any socket error should close the connection, but some errors are
83
96
            # due to the client closing early and we don't want to pollute test
88
101
                                     errno.ECONNABORTED, errno.EBADF)):
89
102
                raise
90
103
 
 
104
    error_content_type = 'text/plain'
 
105
    error_message_format = '''\
 
106
Error code: %(code)s.
 
107
Message: %(message)s.
 
108
'''
 
109
 
 
110
    def send_error(self, code, message=None):
 
111
        """Send and log an error reply.
 
112
 
 
113
        We redefine the python-provided version to be able to set a 
 
114
        ``Content-Length`` header as some http/1.1 clients complain otherwise
 
115
        (see bug #568421).
 
116
 
 
117
        :param code: The HTTP error code.
 
118
 
 
119
        :param message: The explanation of the error code, Defaults to a short
 
120
             entry.
 
121
        """
 
122
 
 
123
        if message is None:
 
124
            try:
 
125
                message = self.responses[code][0]
 
126
            except KeyError:
 
127
                message = '???'
 
128
        self.log_error("code %d, message %s", code, message)
 
129
        content = (self.error_message_format %
 
130
                   {'code': code, 'message': message})
 
131
        self.send_response(code, message)
 
132
        self.send_header("Content-Type", self.error_content_type)
 
133
        self.send_header("Content-Length", "%d" % len(content))
 
134
        self.send_header('Connection', 'close')
 
135
        self.end_headers()
 
136
        if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
 
137
            self.wfile.write(content)
 
138
 
 
139
    def _handle_one_request(self):
 
140
        SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
 
141
 
91
142
    _range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
92
143
    _tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
93
144
 
212
263
            # mode may cause newline translations, making the
213
264
            # actual size of the content transmitted *less* than
214
265
            # the content-length!
215
 
            file = open(path, 'rb')
 
266
            f = open(path, 'rb')
216
267
        except IOError:
217
268
            self.send_error(404, "File not found")
218
269
            return
219
270
 
220
 
        file_size = os.fstat(file.fileno())[6]
 
271
        file_size = os.fstat(f.fileno())[6]
221
272
        tail, ranges = self.parse_ranges(ranges_header_value)
222
273
        # Normalize tail into ranges
223
274
        if tail != 0:
244
295
            # RFC2616 14.16 and 14.35 says that when a server
245
296
            # encounters unsatisfiable range specifiers, it
246
297
            # SHOULD return a 416.
247
 
            file.close()
 
298
            f.close()
248
299
            # FIXME: We SHOULD send a Content-Range header too,
249
300
            # but the implementation of send_error does not
250
301
            # allows that. So far.
253
304
 
254
305
        if len(ranges) == 1:
255
306
            (start, end) = ranges[0]
256
 
            self.get_single_range(file, file_size, start, end)
 
307
            self.get_single_range(f, file_size, start, end)
257
308
        else:
258
 
            self.get_multiple_ranges(file, file_size, ranges)
259
 
        file.close()
 
309
            self.get_multiple_ranges(f, file_size, ranges)
 
310
        f.close()
260
311
 
261
312
    def translate_path(self, path):
262
313
        """Translate a /-separated PATH to the local filename syntax.
318
369
        self.test_case_server = test_case_server
319
370
        self._home_dir = test_case_server._home_dir
320
371
 
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):
 
372
 
 
373
class TestingHTTPServer(test_server.TestingTCPServer, TestingHTTPServerMixin):
358
374
 
359
375
    def __init__(self, server_address, request_handler_class,
360
376
                 test_case_server):
 
377
        test_server.TestingTCPServer.__init__(self, server_address,
 
378
                                              request_handler_class)
361
379
        TestingHTTPServerMixin.__init__(self, test_case_server)
362
 
        SocketServer.TCPServer.__init__(self, server_address,
363
 
                                        request_handler_class)
364
 
 
365
 
 
366
 
class TestingThreadingHTTPServer(SocketServer.ThreadingTCPServer,
 
380
 
 
381
 
 
382
class TestingThreadingHTTPServer(test_server.TestingThreadingTCPServer,
367
383
                                 TestingHTTPServerMixin):
368
384
    """A threading HTTP test server for HTTP 1.1.
369
385
 
371
387
    server, we need an independent connection for each of them. We achieve that
372
388
    by spawning a new thread for each connection.
373
389
    """
374
 
 
375
390
    def __init__(self, server_address, request_handler_class,
376
391
                 test_case_server):
 
392
        test_server.TestingThreadingTCPServer.__init__(self, server_address,
 
393
                                                       request_handler_class)
377
394
        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):
 
395
 
 
396
 
 
397
class HttpServer(test_server.TestingTCPServerInAThread):
404
398
    """A test server for http transports.
405
399
 
406
400
    Subclasses can provide a specific request handler.
428
422
        :param protocol_version: if specified, will override the protocol
429
423
            version of the request handler.
430
424
        """
431
 
        transport.Server.__init__(self)
432
 
        self.request_handler = request_handler
 
425
        # Depending on the protocol version, we will create the approriate
 
426
        # server
 
427
        if protocol_version is None:
 
428
            # Use the request handler one
 
429
            proto_vers = request_handler.protocol_version
 
430
        else:
 
431
            # Use our own, it will be used to override the request handler
 
432
            # one too.
 
433
            proto_vers = protocol_version
 
434
        # Get the appropriate server class for the required protocol
 
435
        serv_cls = self.http_server_class.get(proto_vers, None)
 
436
        if serv_cls is None:
 
437
            raise httplib.UnknownProtocol(proto_vers)
433
438
        self.host = 'localhost'
434
439
        self.port = 0
435
 
        self._httpd = None
436
 
        self.protocol_version = protocol_version
 
440
        super(HttpServer, self).__init__((self.host, self.port),
 
441
                                         serv_cls,
 
442
                                         request_handler)
 
443
        self.protocol_version = proto_vers
437
444
        # Allows tests to verify number of GET requests issued
438
445
        self.GET_request_nb = 0
439
 
 
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
 
    def _get_httpd(self):
448
 
        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)
465
 
            host, self.port = self._httpd.socket.getsockname()
466
 
        return self._httpd
467
 
 
468
 
    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()
486
 
 
487
 
        # From now on, exceptions are taken care of by the
488
 
        # SocketServer.BaseServer or the request handler.
489
 
        while self._http_running:
490
 
            try:
491
 
                # Really an HTTP connection but the python framework is generic
492
 
                # and call them requests
493
 
                httpd.handle_request()
494
 
            except socket.timeout:
495
 
                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
 
446
        self._http_base_url = None
 
447
        self.logs = []
 
448
 
 
449
    def create_server(self):
 
450
        return self.server_class(
 
451
            (self.host, self.port), self.request_handler_class, self)
504
452
 
505
453
    def _get_remote_url(self, path):
506
454
        path_parts = path.split(os.path.sep)
518
466
        """Capture Server log output."""
519
467
        self.logs.append(format % args)
520
468
 
521
 
    def setUp(self, backing_transport_server=None):
522
 
        """See bzrlib.transport.Server.setUp.
 
469
    def start_server(self, backing_transport_server=None):
 
470
        """See bzrlib.transport.Server.start_server.
523
471
 
524
472
        :param backing_transport_server: The transport that requests over this
525
473
            protocol should be forwarded to. Note that this is currently not
527
475
        """
528
476
        # XXX: TODO: make the server back onto vfs_server rather than local
529
477
        # disk.
530
 
        if not (backing_transport_server is None or \
531
 
                isinstance(backing_transport_server, local.LocalURLServer)):
 
478
        if not (backing_transport_server is None
 
479
                or isinstance(backing_transport_server,
 
480
                              test_server.LocalURLServer)):
532
481
            raise AssertionError(
533
 
                "HTTPServer currently assumes local transport, got %s" % \
 
482
                "HTTPServer currently assumes local transport, got %s" %
534
483
                backing_transport_server)
535
484
        self._home_dir = os.getcwdu()
536
485
        self._local_path_parts = self._home_dir.split(os.path.sep)
537
 
        self._http_base_url = None
538
 
 
539
 
        # Create the server thread
540
 
        self._http_starting = threading.Lock()
541
 
        self._http_starting.acquire()
542
 
        self._http_thread = threading.Thread(target=self._http_start)
543
 
        self._http_thread.setDaemon(True)
544
 
        self._http_exception = None
545
 
        self._http_thread.start()
546
 
 
547
 
        # Wait for the server thread to start (i.e release the lock)
548
 
        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
 
        self._http_starting.release()
555
486
        self.logs = []
556
487
 
557
 
    def tearDown(self):
558
 
        """See bzrlib.transport.Server.tearDown."""
559
 
        self._httpd.tearDown()
560
 
        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.
 
488
        super(HttpServer, self).start_server()
 
489
        self._http_base_url = '%s://%s:%s/' % (
 
490
            self._url_protocol, self.host, self.port)
564
491
 
565
492
    def get_url(self):
566
493
        """See bzrlib.transport.Server.get_url."""