← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_server.py

  • Committer: Patch Queue Manager
  • Date: 2011-10-09 13:52:06 UTC
  • mfrom: (6202.1.3 revno-revision)
  • Revision ID: pqm@pqm.ubuntu.com-20111009135206-t3utsln6mtzv9eut
(jelmer) Add a --revision argument to 'bzr revno'. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_server.py
19
19
import SocketServer
20
20
import sys
21
21
import threading
 
22
import traceback
22
23
 
23
24
 
24
25
from bzrlib import (
25
26
    cethread,
 
27
    errors,
26
28
    osutils,
27
29
    transport,
28
30
    urlutils,
212
214
    def start_server(self, backing_server=None):
213
215
        """Setup the Chroot on backing_server."""
214
216
        if backing_server is not None:
215
 
            self.backing_transport = transport.get_transport(
 
217
            self.backing_transport = transport.get_transport_from_url(
216
218
                backing_server.get_url())
217
219
        else:
218
 
            self.backing_transport = transport.get_transport('.')
 
220
            self.backing_transport = transport.get_transport_from_path('.')
219
221
        self.backing_transport.clone('added-by-filter').ensure_base()
220
222
        self.filter_func = lambda x: 'added-by-filter/' + x
221
223
        super(TestingPathFilteringServer, self).start_server()
233
235
    def start_server(self, backing_server=None):
234
236
        """Setup the Chroot on backing_server."""
235
237
        if backing_server is not None:
236
 
            self.backing_transport = transport.get_transport(
 
238
            self.backing_transport = transport.get_transport_from_url(
237
239
                backing_server.get_url())
238
240
        else:
239
 
            self.backing_transport = transport.get_transport('.')
 
241
            self.backing_transport = transport.get_transport_from_path('.')
240
242
        super(TestingChrootServer, self).start_server()
241
243
 
242
244
    def get_bogus_url(self):
265
267
            #raise AssertionError('thread %s hung' % (self.name,))
266
268
 
267
269
 
268
 
class TestingTCPServerMixin:
 
270
class TestingTCPServerMixin(object):
269
271
    """Mixin to support running SocketServer.TCPServer in a thread.
270
272
 
271
273
    Tests are connecting from the main thread, the server has to be run in a
312
314
                self.process_request(request, client_address)
313
315
            except:
314
316
                self.handle_error(request, client_address)
315
 
                self.close_request(request)
 
317
        else:
 
318
            self.close_request(request)
316
319
 
317
320
    def get_request(self):
318
321
        return self.socket.accept()
332
335
        # The following can be used for debugging purposes, it will display the
333
336
        # exception and the traceback just when it occurs instead of waiting
334
337
        # for the thread to be joined.
335
 
 
336
338
        # SocketServer.BaseServer.handle_error(self, request, client_address)
 
339
 
 
340
        # We call close_request manually, because we are going to raise an
 
341
        # exception. The SocketServer implementation calls:
 
342
        #   handle_error(...)
 
343
        #   close_request(...)
 
344
        # But because we raise the exception, close_request will never be
 
345
        # triggered. This helps client not block waiting for a response when
 
346
        # the server gets an exception.
 
347
        self.close_request(request)
337
348
        raise
338
349
 
339
350
    def ignored_exceptions_during_shutdown(self, e):
419
430
        SocketServer.ThreadingTCPServer.__init__(self, server_address,
420
431
                                                 request_handler_class)
421
432
 
422
 
    def get_request (self):
 
433
    def get_request(self):
423
434
        """Get the request and client address from the socket."""
424
435
        sock, addr = TestingTCPServerMixin.get_request(self)
425
436
        # The thread is not create yet, it will be updated in process_request
440
451
        t = TestThread(
441
452
            sync_event=stopped,
442
453
            name='%s -> %s' % (client_address, self.server_address),
443
 
            target = self.process_request_thread,
444
 
            args = (started, stopped, request, client_address))
 
454
            target=self.process_request_thread,
 
455
            args=(started, stopped, request, client_address))
445
456
        # Update the client description
446
457
        self.clients.pop()
447
458
        self.clients.append((request, client_address, t))
589
600
    def __init__(self, request, client_address, server):
590
601
        medium.SmartServerSocketStreamMedium.__init__(
591
602
            self, request, server.backing_transport,
592
 
            server.root_client_path)
 
603
            server.root_client_path,
 
604
            timeout=_DEFAULT_TESTING_CLIENT_TIMEOUT)
593
605
        request.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
594
606
        SocketServer.BaseRequestHandler.__init__(self, request, client_address,
595
607
                                                 server)
596
608
 
597
609
    def handle(self):
598
 
        while not self.finished:
599
 
            server_protocol = self._build_protocol()
600
 
            self._serve_one_request(server_protocol)
601
 
 
 
610
        try:
 
611
            while not self.finished:
 
612
                server_protocol = self._build_protocol()
 
613
                self._serve_one_request(server_protocol)
 
614
        except errors.ConnectionTimeout:
 
615
            # idle connections aren't considered a failure of the server
 
616
            return
 
617
 
 
618
 
 
619
_DEFAULT_TESTING_CLIENT_TIMEOUT = 60.0
602
620
 
603
621
class TestingSmartServer(TestingThreadingTCPServer, server.SmartTCPServer):
604
622
 
607
625
        TestingThreadingTCPServer.__init__(self, server_address,
608
626
                                           request_handler_class)
609
627
        server.SmartTCPServer.__init__(self, backing_transport,
610
 
                                       root_client_path)
 
628
            root_client_path, client_timeout=_DEFAULT_TESTING_CLIENT_TIMEOUT)
 
629
 
611
630
    def serve(self):
612
631
        self.run_server_started_hooks()
613
632
        try:
665
684
        self.chroot_server = ChrootServer(
666
685
            self.get_backing_transport(backing_transport_server))
667
686
        self.chroot_server.start_server()
668
 
        self.backing_transport = transport.get_transport(
 
687
        self.backing_transport = transport.get_transport_from_url(
669
688
            self.chroot_server.get_url())
670
689
        super(SmartTCPServer_for_testing, self).start_server()
671
690
 
677
696
 
678
697
    def get_backing_transport(self, backing_transport_server):
679
698
        """Get a backing transport from a server we are decorating."""
680
 
        return transport.get_transport(backing_transport_server.get_url())
 
699
        return transport.get_transport_from_url(
 
700
            backing_transport_server.get_url())
681
701
 
682
702
    def get_url(self):
683
703
        url = self.server.get_url()
694
714
    def get_backing_transport(self, backing_transport_server):
695
715
        """Get a backing transport from a server we are decorating."""
696
716
        url = 'readonly+' + backing_transport_server.get_url()
697
 
        return transport.get_transport(url)
 
717
        return transport.get_transport_from_url(url)
698
718
 
699
719
 
700
720
class SmartTCPServer_for_testing_v2_only(SmartTCPServer_for_testing):
715
735
    def get_backing_transport(self, backing_transport_server):
716
736
        """Get a backing transport from a server we are decorating."""
717
737
        url = 'readonly+' + backing_transport_server.get_url()
718
 
        return transport.get_transport(url)
 
738
        return transport.get_transport_from_url(url)