← 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: Canonical.com Patch Queue Manager
  • Date: 2011-05-18 13:02:52 UTC
  • mfrom: (5830.3.6 i18n-msgfmt)
  • Revision ID: pqm@pqm.ubuntu.com-20110518130252-ky96qcvzt6o0zg3f
(mbp) add build_mo command to setup.py (INADA Naoki)

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
289
287
 
290
288
    def serve(self):
291
289
        self.serving = True
 
290
        self.stopped.clear()
292
291
        # We are listening and ready to accept connections
293
292
        self.started.set()
294
293
        try:
313
312
                self.process_request(request, client_address)
314
313
            except:
315
314
                self.handle_error(request, client_address)
316
 
        else:
317
 
            self.close_request(request)
 
315
                self.close_request(request)
318
316
 
319
317
    def get_request(self):
320
318
        return self.socket.accept()
334
332
        # The following can be used for debugging purposes, it will display the
335
333
        # exception and the traceback just when it occurs instead of waiting
336
334
        # for the thread to be joined.
 
335
 
337
336
        # 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
337
        raise
348
338
 
349
339
    def ignored_exceptions_during_shutdown(self, e):
429
419
        SocketServer.ThreadingTCPServer.__init__(self, server_address,
430
420
                                                 request_handler_class)
431
421
 
432
 
    def get_request(self):
 
422
    def get_request (self):
433
423
        """Get the request and client address from the socket."""
434
424
        sock, addr = TestingTCPServerMixin.get_request(self)
435
 
        # The thread is not created yet, it will be updated in process_request
 
425
        # The thread is not create yet, it will be updated in process_request
436
426
        self.clients.append((sock, addr, None))
437
427
        return sock, addr
438
428
 
439
 
    def process_request_thread(self, started, detached, stopped,
440
 
                               request, client_address):
 
429
    def process_request_thread(self, started, stopped, request, client_address):
441
430
        started.set()
442
 
        # We will be on our own once the server tells us we're detached
443
 
        detached.wait()
444
431
        SocketServer.ThreadingTCPServer.process_request_thread(
445
432
            self, request, client_address)
446
433
        self.close_request(request)
449
436
    def process_request(self, request, client_address):
450
437
        """Start a new thread to process the request."""
451
438
        started = threading.Event()
452
 
        detached = threading.Event()
453
439
        stopped = threading.Event()
454
440
        t = TestThread(
455
441
            sync_event=stopped,
456
442
            name='%s -> %s' % (client_address, self.server_address),
457
443
            target = self.process_request_thread,
458
 
            args = (started, detached, stopped, request, client_address))
 
444
            args = (started, stopped, request, client_address))
459
445
        # Update the client description
460
446
        self.clients.pop()
461
447
        self.clients.append((request, client_address, t))
464
450
        t.set_ignored_exceptions(self.ignored_exceptions)
465
451
        t.start()
466
452
        started.wait()
 
453
        if debug_threads():
 
454
            sys.stderr.write('Client thread %s started\n' % (t.name,))
467
455
        # If an exception occured during the thread start, it will get raised.
468
456
        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
457
 
474
458
    # The following methods are called by the main thread
475
459
 
524
508
            sync_event=self.server.started,
525
509
            target=self.run_server)
526
510
        self._server_thread.start()
527
 
        # Wait for the server thread to start (i.e. release the lock)
 
511
        # Wait for the server thread to start (i.e release the lock)
528
512
        self.server.started.wait()
529
513
        # Get the real address, especially the port
530
514
        self.host, self.port = self.server.server_address
605
589
    def __init__(self, request, client_address, server):
606
590
        medium.SmartServerSocketStreamMedium.__init__(
607
591
            self, request, server.backing_transport,
608
 
            server.root_client_path,
609
 
            timeout=_DEFAULT_TESTING_CLIENT_TIMEOUT)
 
592
            server.root_client_path)
610
593
        request.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
611
594
        SocketServer.BaseRequestHandler.__init__(self, request, client_address,
612
595
                                                 server)
613
596
 
614
597
    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
 
598
        while not self.finished:
 
599
            server_protocol = self._build_protocol()
 
600
            self._serve_one_request(server_protocol)
 
601
 
625
602
 
626
603
class TestingSmartServer(TestingThreadingTCPServer, server.SmartTCPServer):
627
604
 
630
607
        TestingThreadingTCPServer.__init__(self, server_address,
631
608
                                           request_handler_class)
632
609
        server.SmartTCPServer.__init__(self, backing_transport,
633
 
            root_client_path, client_timeout=_DEFAULT_TESTING_CLIENT_TIMEOUT)
634
 
 
 
610
                                       root_client_path)
635
611
    def serve(self):
636
612
        self.run_server_started_hooks()
637
613
        try:
689
665
        self.chroot_server = ChrootServer(
690
666
            self.get_backing_transport(backing_transport_server))
691
667
        self.chroot_server.start_server()
692
 
        self.backing_transport = transport.get_transport_from_url(
 
668
        self.backing_transport = transport.get_transport(
693
669
            self.chroot_server.get_url())
694
670
        super(SmartTCPServer_for_testing, self).start_server()
695
671
 
701
677
 
702
678
    def get_backing_transport(self, backing_transport_server):
703
679
        """Get a backing transport from a server we are decorating."""
704
 
        return transport.get_transport_from_url(
705
 
            backing_transport_server.get_url())
 
680
        return transport.get_transport(backing_transport_server.get_url())
706
681
 
707
682
    def get_url(self):
708
683
        url = self.server.get_url()
719
694
    def get_backing_transport(self, backing_transport_server):
720
695
        """Get a backing transport from a server we are decorating."""
721
696
        url = 'readonly+' + backing_transport_server.get_url()
722
 
        return transport.get_transport_from_url(url)
 
697
        return transport.get_transport(url)
723
698
 
724
699
 
725
700
class SmartTCPServer_for_testing_v2_only(SmartTCPServer_for_testing):
740
715
    def get_backing_transport(self, backing_transport_server):
741
716
        """Get a backing transport from a server we are decorating."""
742
717
        url = 'readonly+' + backing_transport_server.get_url()
743
 
        return transport.get_transport_from_url(url)
 
718
        return transport.get_transport(url)