← 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: 2012-03-13 16:42:20 UTC
  • mto: This revision was merged to the branch mainline in revision 6512.
  • Revision ID: v.ladeuil+lp@free.fr-20120313164220-atkou2zprhlspmwg
Mention that a given config option cannot be safely handled via both APIs at the same time.

Show diffs side-by-side

added added

removed removed

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