← 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: 2010-02-09 17:27:46 UTC
  • mto: (5029.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5030.
  • Revision ID: v.ladeuil+lp@free.fr-20100209172746-6f4mvlnr2mac807j
Move NoSmartTransportServer to bzrlib.tests.test_server

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
30
30
import urllib
31
31
import urlparse
32
32
 
33
 
from bzrlib import (
34
 
    osutils,
35
 
    tests,
36
 
    transport,
37
 
    )
38
 
from bzrlib.tests import test_server
 
33
from bzrlib import transport
39
34
from bzrlib.transport import local
40
35
 
41
36
 
75
70
                self.headers.get('referer', '-'),
76
71
                self.headers.get('user-agent', '-'))
77
72
 
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
 
 
86
73
    def handle_one_request(self):
87
74
        """Handle a single HTTP request.
88
75
 
90
77
        connection early to avoid polluting the test results.
91
78
        """
92
79
        try:
93
 
            self._handle_one_request()
 
80
            SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
94
81
        except socket.error, e:
95
82
            # Any socket error should close the connection, but some errors are
96
83
            # due to the client closing early and we don't want to pollute test
101
88
                                     errno.ECONNABORTED, errno.EBADF)):
102
89
                raise
103
90
 
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
 
 
142
91
    _range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
143
92
    _tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
144
93
 
263
212
            # mode may cause newline translations, making the
264
213
            # actual size of the content transmitted *less* than
265
214
            # the content-length!
266
 
            f = open(path, 'rb')
 
215
            file = open(path, 'rb')
267
216
        except IOError:
268
217
            self.send_error(404, "File not found")
269
218
            return
270
219
 
271
 
        file_size = os.fstat(f.fileno())[6]
 
220
        file_size = os.fstat(file.fileno())[6]
272
221
        tail, ranges = self.parse_ranges(ranges_header_value)
273
222
        # Normalize tail into ranges
274
223
        if tail != 0:
295
244
            # RFC2616 14.16 and 14.35 says that when a server
296
245
            # encounters unsatisfiable range specifiers, it
297
246
            # SHOULD return a 416.
298
 
            f.close()
 
247
            file.close()
299
248
            # FIXME: We SHOULD send a Content-Range header too,
300
249
            # but the implementation of send_error does not
301
250
            # allows that. So far.
304
253
 
305
254
        if len(ranges) == 1:
306
255
            (start, end) = ranges[0]
307
 
            self.get_single_range(f, file_size, start, end)
 
256
            self.get_single_range(file, file_size, start, end)
308
257
        else:
309
 
            self.get_multiple_ranges(f, file_size, ranges)
310
 
        f.close()
 
258
            self.get_multiple_ranges(file, file_size, ranges)
 
259
        file.close()
311
260
 
312
261
    def translate_path(self, path):
313
262
        """Translate a /-separated PATH to the local filename syntax.
369
318
        self.test_case_server = test_case_server
370
319
        self._home_dir = test_case_server._home_dir
371
320
 
372
 
 
373
 
class TestingHTTPServer(test_server.TestingTCPServer, TestingHTTPServerMixin):
 
321
    def stop_server(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.stop_server() 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):
374
358
 
375
359
    def __init__(self, server_address, request_handler_class,
376
360
                 test_case_server):
377
 
        test_server.TestingTCPServer.__init__(self, server_address,
378
 
                                              request_handler_class)
379
361
        TestingHTTPServerMixin.__init__(self, test_case_server)
380
 
 
381
 
 
382
 
class TestingThreadingHTTPServer(test_server.TestingThreadingTCPServer,
 
362
        SocketServer.TCPServer.__init__(self, server_address,
 
363
                                        request_handler_class)
 
364
 
 
365
 
 
366
class TestingThreadingHTTPServer(SocketServer.ThreadingTCPServer,
383
367
                                 TestingHTTPServerMixin):
384
368
    """A threading HTTP test server for HTTP 1.1.
385
369
 
387
371
    server, we need an independent connection for each of them. We achieve that
388
372
    by spawning a new thread for each connection.
389
373
    """
 
374
 
390
375
    def __init__(self, server_address, request_handler_class,
391
376
                 test_case_server):
392
 
        test_server.TestingThreadingTCPServer.__init__(self, server_address,
393
 
                                                       request_handler_class)
394
377
        TestingHTTPServerMixin.__init__(self, test_case_server)
395
 
 
396
 
 
397
 
class HttpServer(test_server.TestingTCPServerInAThread):
 
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):
398
404
    """A test server for http transports.
399
405
 
400
406
    Subclasses can provide a specific request handler.
422
428
        :param protocol_version: if specified, will override the protocol
423
429
            version of the request handler.
424
430
        """
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)
 
431
        transport.Server.__init__(self)
 
432
        self.request_handler = request_handler
438
433
        self.host = 'localhost'
439
434
        self.port = 0
440
 
        super(HttpServer, self).__init__((self.host, self.port),
441
 
                                         serv_cls,
442
 
                                         request_handler)
443
 
        self.protocol_version = proto_vers
 
435
        self._httpd = None
 
436
        self.protocol_version = protocol_version
444
437
        # Allows tests to verify number of GET requests issued
445
438
        self.GET_request_nb = 0
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)
 
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
            self.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
                    or (sys.platform == 'win32' and e[0] == 10038)):
 
499
                    # Starting with python-2.6, handle_request may raise socket
 
500
                    # or select exceptions when the server is shut down (as we
 
501
                    # do).
 
502
                    # 10038 = WSAENOTSOCK
 
503
                    # http://msdn.microsoft.com/en-us/library/ms740668%28VS.85%29.aspx
 
504
                    pass
 
505
                else:
 
506
                    raise
452
507
 
453
508
    def _get_remote_url(self, path):
454
509
        path_parts = path.split(os.path.sep)
475
530
        """
476
531
        # XXX: TODO: make the server back onto vfs_server rather than local
477
532
        # disk.
478
 
        if not (backing_transport_server is None
479
 
                or isinstance(backing_transport_server,
480
 
                              test_server.LocalURLServer)):
 
533
        if not (backing_transport_server is None or \
 
534
                isinstance(backing_transport_server, local.LocalURLServer)):
481
535
            raise AssertionError(
482
 
                "HTTPServer currently assumes local transport, got %s" %
 
536
                "HTTPServer currently assumes local transport, got %s" % \
483
537
                backing_transport_server)
484
538
        self._home_dir = os.getcwdu()
485
539
        self._local_path_parts = self._home_dir.split(os.path.sep)
 
540
        self._http_base_url = None
 
541
 
 
542
        # Create the server thread
 
543
        self._http_starting = threading.Lock()
 
544
        self._http_starting.acquire()
 
545
        self._http_thread = threading.Thread(target=self._http_start)
 
546
        self._http_thread.setDaemon(True)
 
547
        self._http_exception = None
 
548
        self._http_thread.start()
 
549
 
 
550
        # Wait for the server thread to start (i.e release the lock)
 
551
        self._http_starting.acquire()
 
552
 
 
553
        if self._http_exception is not None:
 
554
            # Something went wrong during server start
 
555
            exc_class, exc_value, exc_tb = self._http_exception
 
556
            raise exc_class, exc_value, exc_tb
 
557
        self._http_starting.release()
486
558
        self.logs = []
487
559
 
488
 
        super(HttpServer, self).start_server()
489
 
        self._http_base_url = '%s://%s:%s/' % (
490
 
            self._url_protocol, self.host, self.port)
 
560
    def stop_server(self):
 
561
        self._httpd.stop_server()
 
562
        self._http_running = False
 
563
        # We don't need to 'self._http_thread.join()' here since the thread is
 
564
        # a daemonic one and will be garbage collected anyway. Joining just
 
565
        # slows us down for no added benefit.
491
566
 
492
567
    def get_url(self):
493
568
        """See bzrlib.transport.Server.get_url."""