← 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: Samuel Bronson
  • Date: 2012-08-30 20:36:18 UTC
  • mto: (6015.57.3 2.4)
  • mto: This revision was merged to the branch mainline in revision 6558.
  • Revision ID: naesten@gmail.com-20120830203618-y2dzw91nqpvpgxvx
Update INSTALL for switch to Python 2.6 and up.

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
23
22
 
24
23
 
25
24
from bzrlib import (
26
25
    cethread,
27
 
    errors,
28
26
    osutils,
29
27
    transport,
30
28
    urlutils,
214
212
    def start_server(self, backing_server=None):
215
213
        """Setup the Chroot on backing_server."""
216
214
        if backing_server is not None:
217
 
            self.backing_transport = transport.get_transport_from_url(
 
215
            self.backing_transport = transport.get_transport(
218
216
                backing_server.get_url())
219
217
        else:
220
 
            self.backing_transport = transport.get_transport_from_path('.')
 
218
            self.backing_transport = transport.get_transport('.')
221
219
        self.backing_transport.clone('added-by-filter').ensure_base()
222
220
        self.filter_func = lambda x: 'added-by-filter/' + x
223
221
        super(TestingPathFilteringServer, self).start_server()
235
233
    def start_server(self, backing_server=None):
236
234
        """Setup the Chroot on backing_server."""
237
235
        if backing_server is not None:
238
 
            self.backing_transport = transport.get_transport_from_url(
 
236
            self.backing_transport = transport.get_transport(
239
237
                backing_server.get_url())
240
238
        else:
241
 
            self.backing_transport = transport.get_transport_from_path('.')
 
239
            self.backing_transport = transport.get_transport('.')
242
240
        super(TestingChrootServer, self).start_server()
243
241
 
244
242
    def get_bogus_url(self):
267
265
            #raise AssertionError('thread %s hung' % (self.name,))
268
266
 
269
267
 
270
 
class TestingTCPServerMixin(object):
 
268
class TestingTCPServerMixin:
271
269
    """Mixin to support running SocketServer.TCPServer in a thread.
272
270
 
273
271
    Tests are connecting from the main thread, the server has to be run in a
313
311
                self.process_request(request, client_address)
314
312
            except:
315
313
                self.handle_error(request, client_address)
316
 
        else:
317
 
            self.close_request(request)
 
314
                self.close_request(request)
318
315
 
319
316
    def get_request(self):
320
317
        return self.socket.accept()
334
331
        # The following can be used for debugging purposes, it will display the
335
332
        # exception and the traceback just when it occurs instead of waiting
336
333
        # for the thread to be joined.
 
334
 
337
335
        # SocketServer.BaseServer.handle_error(self, request, client_address)
338
 
 
339
 
        # We call close_request manually, because we are going to raise an
340
 
        # exception. The SocketServer implementation calls:
341
 
        #   handle_error(...)
342
 
        #   close_request(...)
343
 
        # But because we raise the exception, close_request will never be
344
 
        # triggered. This helps client not block waiting for a response when
345
 
        # the server gets an exception.
346
 
        self.close_request(request)
347
336
        raise
348
337
 
349
338
    def ignored_exceptions_during_shutdown(self, e):
429
418
        SocketServer.ThreadingTCPServer.__init__(self, server_address,
430
419
                                                 request_handler_class)
431
420
 
432
 
    def get_request(self):
 
421
    def get_request (self):
433
422
        """Get the request and client address from the socket."""
434
423
        sock, addr = TestingTCPServerMixin.get_request(self)
435
 
        # The thread is not created yet, it will be updated in process_request
 
424
        # The thread is not create yet, it will be updated in process_request
436
425
        self.clients.append((sock, addr, None))
437
426
        return sock, addr
438
427
 
439
 
    def process_request_thread(self, started, detached, stopped,
440
 
                               request, client_address):
 
428
    def process_request_thread(self, started, stopped, request, client_address):
441
429
        started.set()
442
 
        # We will be on our own once the server tells us we're detached
443
 
        detached.wait()
444
430
        SocketServer.ThreadingTCPServer.process_request_thread(
445
431
            self, request, client_address)
446
432
        self.close_request(request)
449
435
    def process_request(self, request, client_address):
450
436
        """Start a new thread to process the request."""
451
437
        started = threading.Event()
452
 
        detached = threading.Event()
453
438
        stopped = threading.Event()
454
439
        t = TestThread(
455
440
            sync_event=stopped,
456
441
            name='%s -> %s' % (client_address, self.server_address),
457
442
            target = self.process_request_thread,
458
 
            args = (started, detached, stopped, request, client_address))
 
443
            args = (started, stopped, request, client_address))
459
444
        # Update the client description
460
445
        self.clients.pop()
461
446
        self.clients.append((request, client_address, t))
464
449
        t.set_ignored_exceptions(self.ignored_exceptions)
465
450
        t.start()
466
451
        started.wait()
 
452
        if debug_threads():
 
453
            sys.stderr.write('Client thread %s started\n' % (t.name,))
467
454
        # If an exception occured during the thread start, it will get raised.
 
455
        # In rare cases, an exception raised during the request processing may
 
456
        # also get caught here (see http://pad.lv/869366)
468
457
        t.pending_exception()
469
 
        if debug_threads():
470
 
            sys.stderr.write('Client thread %s started\n' % (t.name,))
471
 
        # Tell the thread, it's now on its own for exception handling.
472
 
        detached.set()
473
458
 
474
459
    # The following methods are called by the main thread
475
460
 
605
590
    def __init__(self, request, client_address, server):
606
591
        medium.SmartServerSocketStreamMedium.__init__(
607
592
            self, request, server.backing_transport,
608
 
            server.root_client_path,
609
 
            timeout=_DEFAULT_TESTING_CLIENT_TIMEOUT)
 
593
            server.root_client_path)
610
594
        request.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
611
595
        SocketServer.BaseRequestHandler.__init__(self, request, client_address,
612
596
                                                 server)
613
597
 
614
598
    def handle(self):
615
 
        try:
616
 
            while not self.finished:
617
 
                server_protocol = self._build_protocol()
618
 
                self._serve_one_request(server_protocol)
619
 
        except errors.ConnectionTimeout:
620
 
            # idle connections aren't considered a failure of the server
621
 
            return
622
 
 
623
 
 
624
 
_DEFAULT_TESTING_CLIENT_TIMEOUT = 60.0
 
599
        while not self.finished:
 
600
            server_protocol = self._build_protocol()
 
601
            self._serve_one_request(server_protocol)
 
602
 
625
603
 
626
604
class TestingSmartServer(TestingThreadingTCPServer, server.SmartTCPServer):
627
605
 
630
608
        TestingThreadingTCPServer.__init__(self, server_address,
631
609
                                           request_handler_class)
632
610
        server.SmartTCPServer.__init__(self, backing_transport,
633
 
            root_client_path, client_timeout=_DEFAULT_TESTING_CLIENT_TIMEOUT)
634
 
 
 
611
                                       root_client_path)
635
612
    def serve(self):
636
613
        self.run_server_started_hooks()
637
614
        try:
689
666
        self.chroot_server = ChrootServer(
690
667
            self.get_backing_transport(backing_transport_server))
691
668
        self.chroot_server.start_server()
692
 
        self.backing_transport = transport.get_transport_from_url(
 
669
        self.backing_transport = transport.get_transport(
693
670
            self.chroot_server.get_url())
694
671
        super(SmartTCPServer_for_testing, self).start_server()
695
672
 
701
678
 
702
679
    def get_backing_transport(self, backing_transport_server):
703
680
        """Get a backing transport from a server we are decorating."""
704
 
        return transport.get_transport_from_url(
705
 
            backing_transport_server.get_url())
 
681
        return transport.get_transport(backing_transport_server.get_url())
706
682
 
707
683
    def get_url(self):
708
684
        url = self.server.get_url()
719
695
    def get_backing_transport(self, backing_transport_server):
720
696
        """Get a backing transport from a server we are decorating."""
721
697
        url = 'readonly+' + backing_transport_server.get_url()
722
 
        return transport.get_transport_from_url(url)
 
698
        return transport.get_transport(url)
723
699
 
724
700
 
725
701
class SmartTCPServer_for_testing_v2_only(SmartTCPServer_for_testing):
740
716
    def get_backing_transport(self, backing_transport_server):
741
717
        """Get a backing transport from a server we are decorating."""
742
718
        url = 'readonly+' + backing_transport_server.get_url()
743
 
        return transport.get_transport_from_url(url)
 
719
        return transport.get_transport(url)