← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/http_server.py

Merge bzr.dev into cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/http_server.py
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
    )
34
38
from bzrlib.tests import test_server
35
39
from bzrlib.transport import local
36
40
 
71
75
                self.headers.get('referer', '-'),
72
76
                self.headers.get('user-agent', '-'))
73
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
 
74
86
    def handle_one_request(self):
75
87
        """Handle a single HTTP request.
76
88
 
78
90
        connection early to avoid polluting the test results.
79
91
        """
80
92
        try:
81
 
            SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
 
93
            self._handle_one_request()
82
94
        except socket.error, e:
83
95
            # Any socket error should close the connection, but some errors are
84
96
            # due to the client closing early and we don't want to pollute test
124
136
        if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
125
137
            self.wfile.write(content)
126
138
 
 
139
    def _handle_one_request(self):
 
140
        SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
 
141
 
127
142
    _range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
128
143
    _tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
129
144
 
248
263
            # mode may cause newline translations, making the
249
264
            # actual size of the content transmitted *less* than
250
265
            # the content-length!
251
 
            file = open(path, 'rb')
 
266
            f = open(path, 'rb')
252
267
        except IOError:
253
268
            self.send_error(404, "File not found")
254
269
            return
255
270
 
256
 
        file_size = os.fstat(file.fileno())[6]
 
271
        file_size = os.fstat(f.fileno())[6]
257
272
        tail, ranges = self.parse_ranges(ranges_header_value)
258
273
        # Normalize tail into ranges
259
274
        if tail != 0:
280
295
            # RFC2616 14.16 and 14.35 says that when a server
281
296
            # encounters unsatisfiable range specifiers, it
282
297
            # SHOULD return a 416.
283
 
            file.close()
 
298
            f.close()
284
299
            # FIXME: We SHOULD send a Content-Range header too,
285
300
            # but the implementation of send_error does not
286
301
            # allows that. So far.
289
304
 
290
305
        if len(ranges) == 1:
291
306
            (start, end) = ranges[0]
292
 
            self.get_single_range(file, file_size, start, end)
 
307
            self.get_single_range(f, file_size, start, end)
293
308
        else:
294
 
            self.get_multiple_ranges(file, file_size, ranges)
295
 
        file.close()
 
309
            self.get_multiple_ranges(f, file_size, ranges)
 
310
        f.close()
296
311
 
297
312
    def translate_path(self, path):
298
313
        """Translate a /-separated PATH to the local filename syntax.
354
369
        self.test_case_server = test_case_server
355
370
        self._home_dir = test_case_server._home_dir
356
371
 
357
 
    def stop_server(self):
358
 
         """Called to clean-up the server.
359
 
 
360
 
         Since the server may be (surely is, even) in a blocking listen, we
361
 
         shutdown its socket before closing it.
362
 
         """
363
 
         # Note that is this executed as part of the implicit tear down in the
364
 
         # main thread while the server runs in its own thread. The clean way
365
 
         # to tear down the server is to instruct him to stop accepting
366
 
         # connections and wait for the current connection(s) to end
367
 
         # naturally. To end the connection naturally, the http transports
368
 
         # should close their socket when they do not need to talk to the
369
 
         # server anymore. This happens naturally during the garbage collection
370
 
         # phase of the test transport objetcs (the server clients), so we
371
 
         # don't have to worry about them.  So, for the server, we must tear
372
 
         # down here, from the main thread, when the test have ended.  Note
373
 
         # that since the server is in a blocking operation and since python
374
 
         # use select internally, shutting down the socket is reliable and
375
 
         # relatively clean.
376
 
         try:
377
 
             self.socket.shutdown(socket.SHUT_RDWR)
378
 
         except socket.error, e:
379
 
             # WSAENOTCONN (10057) 'Socket is not connected' is harmless on
380
 
             # windows (occurs before the first connection attempt
381
 
             # vila--20071230)
382
 
 
383
 
             # 'Socket is not connected' can also occur on OSX, with a
384
 
             # "regular" ENOTCONN (when something went wrong during test case
385
 
             # setup leading to self.setUp() *not* being called but
386
 
             # self.stop_server() still being called -- vila20081106
387
 
             if not len(e.args) or e.args[0] not in (errno.ENOTCONN, 10057):
388
 
                 raise
389
 
         # Let the server properly close the socket
390
 
         self.server_close()
391
 
 
392
 
 
393
 
class TestingHTTPServer(SocketServer.TCPServer, TestingHTTPServerMixin):
 
372
 
 
373
class TestingHTTPServer(test_server.TestingTCPServer, TestingHTTPServerMixin):
394
374
 
395
375
    def __init__(self, server_address, request_handler_class,
396
376
                 test_case_server):
 
377
        test_server.TestingTCPServer.__init__(self, server_address,
 
378
                                              request_handler_class)
397
379
        TestingHTTPServerMixin.__init__(self, test_case_server)
398
 
        SocketServer.TCPServer.__init__(self, server_address,
399
 
                                        request_handler_class)
400
 
 
401
 
 
402
 
class TestingThreadingHTTPServer(SocketServer.ThreadingTCPServer,
 
380
 
 
381
 
 
382
class TestingThreadingHTTPServer(test_server.TestingThreadingTCPServer,
403
383
                                 TestingHTTPServerMixin):
404
384
    """A threading HTTP test server for HTTP 1.1.
405
385
 
407
387
    server, we need an independent connection for each of them. We achieve that
408
388
    by spawning a new thread for each connection.
409
389
    """
410
 
 
411
390
    def __init__(self, server_address, request_handler_class,
412
391
                 test_case_server):
 
392
        test_server.TestingThreadingTCPServer.__init__(self, server_address,
 
393
                                                       request_handler_class)
413
394
        TestingHTTPServerMixin.__init__(self, test_case_server)
414
 
        SocketServer.ThreadingTCPServer.__init__(self, server_address,
415
 
                                                 request_handler_class)
416
 
        # Decides how threads will act upon termination of the main
417
 
        # process. This is prophylactic as we should not leave the threads
418
 
        # lying around.
419
 
        self.daemon_threads = True
420
 
 
421
 
    def process_request_thread(self, request, client_address):
422
 
        SocketServer.ThreadingTCPServer.process_request_thread(
423
 
            self, request, client_address)
424
 
        # Under some circumstances (as in bug #383920), we need to force the
425
 
        # shutdown as python delays it until gc occur otherwise and the client
426
 
        # may hang.
427
 
        try:
428
 
            # The request process has been completed, the thread is about to
429
 
            # die, let's shutdown the socket if we can.
430
 
            request.shutdown(socket.SHUT_RDWR)
431
 
        except (socket.error, select.error), e:
432
 
            if e[0] in (errno.EBADF, errno.ENOTCONN):
433
 
                # Right, the socket is already down
434
 
                pass
435
 
            else:
436
 
                raise
437
 
 
438
 
 
439
 
class HttpServer(transport.Server):
 
395
 
 
396
 
 
397
class HttpServer(test_server.TestingTCPServerInAThread):
440
398
    """A test server for http transports.
441
399
 
442
400
    Subclasses can provide a specific request handler.
464
422
        :param protocol_version: if specified, will override the protocol
465
423
            version of the request handler.
466
424
        """
467
 
        transport.Server.__init__(self)
468
 
        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)
469
438
        self.host = 'localhost'
470
439
        self.port = 0
471
 
        self._httpd = None
472
 
        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
473
444
        # Allows tests to verify number of GET requests issued
474
445
        self.GET_request_nb = 0
475
 
 
476
 
    def create_httpd(self, serv_cls, rhandler_cls):
477
 
        return serv_cls((self.host, self.port), self.request_handler, self)
478
 
 
479
 
    def __repr__(self):
480
 
        return "%s(%s:%s)" % \
481
 
            (self.__class__.__name__, self.host, self.port)
482
 
 
483
 
    def _get_httpd(self):
484
 
        if self._httpd is None:
485
 
            rhandler = self.request_handler
486
 
            # Depending on the protocol version, we will create the approriate
487
 
            # server
488
 
            if self.protocol_version is None:
489
 
                # Use the request handler one
490
 
                proto_vers = rhandler.protocol_version
491
 
            else:
492
 
                # Use our own, it will be used to override the request handler
493
 
                # one too.
494
 
                proto_vers = self.protocol_version
495
 
            # Create the appropriate server for the required protocol
496
 
            serv_cls = self.http_server_class.get(proto_vers, None)
497
 
            if serv_cls is None:
498
 
                raise httplib.UnknownProtocol(proto_vers)
499
 
            else:
500
 
                self._httpd = self.create_httpd(serv_cls, rhandler)
501
 
            self.host, self.port = self._httpd.socket.getsockname()
502
 
        return self._httpd
503
 
 
504
 
    def _http_start(self):
505
 
        """Server thread main entry point. """
506
 
        self._http_running = False
507
 
        try:
508
 
            try:
509
 
                httpd = self._get_httpd()
510
 
                self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
511
 
                                                       self.host, self.port)
512
 
                self._http_running = True
513
 
            except:
514
 
                # Whatever goes wrong, we save the exception for the main
515
 
                # thread. Note that since we are running in a thread, no signal
516
 
                # can be received, so we don't care about KeyboardInterrupt.
517
 
                self._http_exception = sys.exc_info()
518
 
        finally:
519
 
            # Release the lock or the main thread will block and the whole
520
 
            # process will hang.
521
 
            self._http_starting.release()
522
 
 
523
 
        # From now on, exceptions are taken care of by the
524
 
        # SocketServer.BaseServer or the request handler.
525
 
        while self._http_running:
526
 
            try:
527
 
                # Really an HTTP connection but the python framework is generic
528
 
                # and call them requests
529
 
                httpd.handle_request()
530
 
            except socket.timeout:
531
 
                pass
532
 
            except (socket.error, select.error), e:
533
 
                if (e[0] == errno.EBADF
534
 
                    or (sys.platform == 'win32' and e[0] == 10038)):
535
 
                    # Starting with python-2.6, handle_request may raise socket
536
 
                    # or select exceptions when the server is shut down (as we
537
 
                    # do).
538
 
                    # 10038 = WSAENOTSOCK
539
 
                    # http://msdn.microsoft.com/en-us/library/ms740668%28VS.85%29.aspx
540
 
                    pass
541
 
                else:
542
 
                    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)
543
452
 
544
453
    def _get_remote_url(self, path):
545
454
        path_parts = path.split(os.path.sep)
570
479
                or isinstance(backing_transport_server,
571
480
                              test_server.LocalURLServer)):
572
481
            raise AssertionError(
573
 
                "HTTPServer currently assumes local transport, got %s" % \
 
482
                "HTTPServer currently assumes local transport, got %s" %
574
483
                backing_transport_server)
575
484
        self._home_dir = os.getcwdu()
576
485
        self._local_path_parts = self._home_dir.split(os.path.sep)
577
 
        self._http_base_url = None
578
 
 
579
 
        # Create the server thread
580
 
        self._http_starting = threading.Lock()
581
 
        self._http_starting.acquire()
582
 
        self._http_thread = threading.Thread(target=self._http_start)
583
 
        self._http_thread.setDaemon(True)
584
 
        self._http_exception = None
585
 
        self._http_thread.start()
586
 
 
587
 
        # Wait for the server thread to start (i.e release the lock)
588
 
        self._http_starting.acquire()
589
 
 
590
 
        if self._http_exception is not None:
591
 
            # Something went wrong during server start
592
 
            exc_class, exc_value, exc_tb = self._http_exception
593
 
            raise exc_class, exc_value, exc_tb
594
 
        self._http_starting.release()
595
486
        self.logs = []
596
487
 
597
 
    def stop_server(self):
598
 
        self._httpd.stop_server()
599
 
        self._http_running = False
600
 
        # We don't need to 'self._http_thread.join()' here since the thread is
601
 
        # a daemonic one and will be garbage collected anyway. Joining just
602
 
        # 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)
603
491
 
604
492
    def get_url(self):
605
493
        """See bzrlib.transport.Server.get_url."""