← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_serve.py

  • Committer: Vincent Ladeuil
  • Date: 2010-04-28 10:33:44 UTC
  • mfrom: (5171.2.3 401599-strict-warnings)
  • mto: This revision was merged to the branch mainline in revision 5191.
  • Revision ID: v.ladeuil+lp@free.fr-20100428103344-e32qf3cn1avdd2cb
Don't mention --no-strict when we just issue the warning about unclean trees

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_serve.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
18
18
"""Tests of the bzr serve command."""
19
19
 
20
20
import os
 
21
import os.path
21
22
import signal
 
23
import subprocess
22
24
import sys
23
25
import thread
24
26
import threading
25
 
import time
26
27
 
27
28
from bzrlib import (
28
29
    builtins,
29
 
    config,
 
30
    debug,
30
31
    errors,
31
32
    osutils,
32
33
    revision as _mod_revision,
33
 
    trace,
34
 
    transport,
35
34
    urlutils,
36
35
    )
37
36
from bzrlib.branch import Branch
38
37
from bzrlib.bzrdir import BzrDir
39
38
from bzrlib.smart import client, medium
40
 
from bzrlib.smart.server import (
41
 
    BzrServerFactory,
42
 
    SmartTCPServer,
43
 
    )
 
39
from bzrlib.smart.server import BzrServerFactory, SmartTCPServer
44
40
from bzrlib.tests import (
45
41
    TestCaseWithMemoryTransport,
46
42
    TestCaseWithTransport,
 
43
    TestSkipped,
47
44
    )
48
 
from bzrlib.transport import remote
 
45
from bzrlib.trace import mutter
 
46
from bzrlib.transport import get_transport, remote
49
47
 
50
48
 
51
49
class TestBzrServeBase(TestCaseWithTransport):
54
52
                                *func_args, **func_kwargs):
55
53
        """Run 'bzr serve', and run the given func in a thread once the server
56
54
        has started.
57
 
 
 
55
        
58
56
        When 'func' terminates, the server will be terminated too.
59
 
 
 
57
        
60
58
        Returns stdout and stderr.
61
59
        """
 
60
        # install hook
 
61
        def on_server_start(backing_urls, tcp_server):
 
62
            t = threading.Thread(
 
63
                target=on_server_start_thread, args=(tcp_server,))
 
64
            t.start()
62
65
        def on_server_start_thread(tcp_server):
63
 
            """This runs concurrently with the server thread.
64
 
 
65
 
            The server is interrupted as soon as ``func`` finishes, even if an
66
 
            exception is encountered.
67
 
            """
68
66
            try:
69
67
                # Run func if set
70
68
                self.tcp_server = tcp_server
71
 
                if func is not None:
 
69
                if not func is None:
72
70
                    try:
73
71
                        func(*func_args, **func_kwargs)
74
72
                    except Exception, e:
75
73
                        # Log errors to make some test failures a little less
76
74
                        # mysterious.
77
 
                        trace.mutter('func broke: %r', e)
 
75
                        mutter('func broke: %r', e)
78
76
            finally:
79
77
                # Then stop the server
80
 
                trace.mutter('interrupting...')
 
78
                mutter('interrupting...')
81
79
                thread.interrupt_main()
82
 
        # When the hook is fired, it just starts ``on_server_start_thread`` and
83
 
        # return
84
 
        def on_server_start(backing_urls, tcp_server):
85
 
            t = threading.Thread(
86
 
                target=on_server_start_thread, args=(tcp_server,))
87
 
            t.start()
88
 
        # install hook
89
80
        SmartTCPServer.hooks.install_named_hook(
90
81
            'server_started_ex', on_server_start,
91
82
            'run_bzr_serve_then_func hook')
92
 
        # It seesm thread.interrupt_main() will not raise KeyboardInterrupt
93
 
        # until after socket.accept returns. So we set the timeout low to make
94
 
        # the test faster.
95
 
        self.overrideAttr(SmartTCPServer, '_ACCEPT_TIMEOUT', 0.1)
96
83
        # start a TCP server
97
84
        try:
98
 
            out, err = self.run_bzr(['serve'] + list(serve_args),
99
 
                                    retcode=retcode)
 
85
            out, err = self.run_bzr(['serve'] + list(serve_args))
100
86
        except KeyboardInterrupt, e:
101
87
            out, err = e.args
102
88
        return out, err
108
94
        super(TestBzrServe, self).setUp()
109
95
        self.disable_missing_extensions_warning()
110
96
 
111
 
    def test_server_exception_with_hook(self):
112
 
        """Catch exception from the server in the server_exception hook.
113
 
 
114
 
        We use ``run_bzr_serve_then_func`` without a ``func`` so the server
115
 
        will receive a KeyboardInterrupt exception we want to catch.
116
 
        """
117
 
        def hook(exception):
118
 
            if exception[0] is KeyboardInterrupt:
119
 
                sys.stderr.write('catching KeyboardInterrupt\n')
120
 
                return True
121
 
            else:
122
 
                return False
123
 
        SmartTCPServer.hooks.install_named_hook(
124
 
            'server_exception', hook,
125
 
            'test_server_except_hook hook')
126
 
        args = ['--port', 'localhost:0', '--quiet']
127
 
        out, err = self.run_bzr_serve_then_func(args, retcode=0)
128
 
        self.assertEqual('catching KeyboardInterrupt\n', err)
129
 
 
130
 
    def test_server_exception_no_hook(self):
131
 
        """test exception without hook returns error"""
132
 
        args = []
133
 
        out, err = self.run_bzr_serve_then_func(args, retcode=3)
134
 
 
135
97
    def assertInetServerShutsdownCleanly(self, process):
136
98
        """Shutdown the server process looking for errors."""
137
99
        # Shutdown the server: the server should shut down when it cannot read
201
163
        url = 'bzr://localhost:%d/' % port
202
164
        self.permit_url(url)
203
165
        return process, url
204
 
 
 
166
    
205
167
    def test_bzr_serve_quiet(self):
206
168
        self.make_branch('.')
207
169
        args = ['--port', 'localhost:0', '--quiet']
230
192
    def test_bzr_serve_port_readonly(self):
231
193
        """bzr server should provide a read only filesystem by default."""
232
194
        process, url = self.start_server_port()
233
 
        t = transport.get_transport_from_url(url)
234
 
        self.assertRaises(errors.TransportNotPossible, t.mkdir, 'adir')
 
195
        transport = get_transport(url)
 
196
        self.assertRaises(errors.TransportNotPossible, transport.mkdir, 'adir')
235
197
        self.assertServerFinishesCleanly(process)
236
198
 
237
199
    def test_bzr_serve_port_readwrite(self):
262
224
        # -Dhpss, and does drop some hpss logging to the file.
263
225
        self.make_branch('.')
264
226
        log_fname = os.getcwd() + '/server.log'
265
 
        self.overrideEnv('BZR_LOG', log_fname)
 
227
        self._captureVar('BZR_LOG', log_fname)
266
228
        process, transport = self.start_server_inet(['-Dhpss'])
267
229
        branch = BzrDir.open_from_transport(transport).open_branch()
268
230
        self.make_read_requests(branch)
272
234
        f.close()
273
235
        self.assertContainsRe(content, r'hpss request: \[[0-9-]+\]')
274
236
 
275
 
    def test_bzr_serve_supports_configurable_timeout(self):
276
 
        gs = config.GlobalStack()
277
 
        gs.set('serve.client_timeout', 0.2)
278
 
        process, url = self.start_server_port()
279
 
        self.build_tree_contents([('a_file', 'contents\n')])
280
 
        # We can connect and issue a request
281
 
        t = transport.get_transport_from_url(url)
282
 
        self.assertEqual('contents\n', t.get_bytes('a_file'))
283
 
        # However, if we just wait for more content from the server, it will
284
 
        # eventually disconnect us.
285
 
        # TODO: Use something like signal.alarm() so that if the server doesn't
286
 
        #       properly handle the timeout, we end up failing the test instead
287
 
        #       of hanging forever.
288
 
        m = t.get_smart_medium()
289
 
        m.read_bytes(1)
290
 
        # Now, we wait for timeout to trigger
291
 
        err = process.stderr.readline()
292
 
        self.assertEqual(
293
 
            'Connection Timeout: disconnecting client after 0.2 seconds\n',
294
 
            err)
295
 
        self.assertServerFinishesCleanly(process)
296
 
 
297
 
    def test_bzr_serve_supports_client_timeout(self):
298
 
        process, url = self.start_server_port(['--client-timeout=0.1'])
299
 
        self.build_tree_contents([('a_file', 'contents\n')])
300
 
        # We can connect and issue a request
301
 
        t = transport.get_transport_from_url(url)
302
 
        self.assertEqual('contents\n', t.get_bytes('a_file'))
303
 
        # However, if we just wait for more content from the server, it will
304
 
        # eventually disconnect us.
305
 
        # TODO: Use something like signal.alarm() so that if the server doesn't
306
 
        #       properly handle the timeout, we end up failing the test instead
307
 
        #       of hanging forever.
308
 
        m = t.get_smart_medium()
309
 
        m.read_bytes(1)
310
 
        # Now, we wait for timeout to trigger
311
 
        err = process.stderr.readline()
312
 
        self.assertEqual(
313
 
            'Connection Timeout: disconnecting client after 0.1 seconds\n',
314
 
            err)
315
 
        self.assertServerFinishesCleanly(process)
316
 
 
317
 
    def test_bzr_serve_graceful_shutdown(self):
318
 
        big_contents = 'a'*64*1024
319
 
        self.build_tree_contents([('bigfile', big_contents)])
320
 
        process, url = self.start_server_port(['--client-timeout=1.0'])
321
 
        t = transport.get_transport_from_url(url)
322
 
        m = t.get_smart_medium()
323
 
        c = client._SmartClient(m)
324
 
        # Start, but don't finish a response
325
 
        resp, response_handler = c.call_expecting_body('get', 'bigfile')
326
 
        self.assertEqual(('ok',), resp)
327
 
        # Note: process.send_signal is a Python 2.6ism
328
 
        process.send_signal(signal.SIGHUP)
329
 
        # Wait for the server to notice the signal, and then read the actual
330
 
        # body of the response. That way we know that it is waiting for the
331
 
        # request to finish
332
 
        self.assertEqual('Requested to stop gracefully\n',
333
 
                         process.stderr.readline())
334
 
        self.assertEqual('Waiting for 1 client(s) to finish\n',
335
 
                         process.stderr.readline())
336
 
        body = response_handler.read_body_bytes()
337
 
        if body != big_contents:
338
 
            self.fail('Failed to properly read the contents of "bigfile"')
339
 
        # Now that our request is finished, the medium should notice it has
340
 
        # been disconnected.
341
 
        self.assertEqual('', m.read_bytes(1))
342
 
        # And the server should be stopping
343
 
        self.assertEqual(0, process.wait())
344
 
 
345
237
 
346
238
class TestCmdServeChrooting(TestBzrServeBase):
347
239
 
383
275
 
384
276
class TestUserdirExpansion(TestCaseWithMemoryTransport):
385
277
 
386
 
    @staticmethod
387
 
    def fake_expanduser(path):
 
278
    def fake_expanduser(self, path):
388
279
        """A simple, environment-independent, function for the duration of this
389
280
        test.
390
281
 
403
294
            self.fake_expanduser, lambda t: base_path)
404
295
        mem_transport = self.get_transport()
405
296
        mem_transport.mkdir_multi(['home', 'home/user'])
406
 
        bzr_server.set_up(mem_transport, None, None, inet=True, timeout=4.0)
 
297
        bzr_server.set_up(mem_transport, None, None, inet=True)
407
298
        self.addCleanup(bzr_server.tear_down)
408
299
        return bzr_server
409
300
 
425
316
        base_url = urlutils.local_path_to_url(base_dir) + '/'
426
317
        # Define a fake 'protocol' to capture the transport that cmd_serve
427
318
        # passes to serve_bzr.
428
 
        def capture_transport(transport, host, port, inet, timeout):
 
319
        def capture_transport(transport, host, port, inet):
429
320
            self.bzr_serve_transport = transport
430
321
        cmd = builtins.cmd_serve()
431
322
        # Read-only
442
333
        self.assertEqual(base_url, self.bzr_serve_transport.base)
443
334
        self.assertEqual(base_dir,
444
335
            server_maker.get_base_path(self.bzr_serve_transport))
 
336