← 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: Andrew Bennetts
  • Date: 2010-10-13 06:14:37 UTC
  • mto: This revision was merged to the branch mainline in revision 5498.
  • Revision ID: andrew.bennetts@canonical.com-20101013061437-2e2m9gro1eusnbb8
Tweaks to the sphinx build.

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
27
 
26
28
from bzrlib import (
27
29
    builtins,
28
 
    config,
 
30
    debug,
29
31
    errors,
30
32
    osutils,
31
33
    revision as _mod_revision,
32
 
    trace,
33
34
    transport,
34
35
    urlutils,
35
36
    )
36
37
from bzrlib.branch import Branch
37
38
from bzrlib.bzrdir import BzrDir
38
39
from bzrlib.smart import client, medium
39
 
from bzrlib.smart.server import (
40
 
    BzrServerFactory,
41
 
    SmartTCPServer,
42
 
    )
 
40
from bzrlib.smart.server import BzrServerFactory, SmartTCPServer
43
41
from bzrlib.tests import (
44
42
    TestCaseWithMemoryTransport,
45
43
    TestCaseWithTransport,
 
44
    TestSkipped,
46
45
    )
 
46
from bzrlib.trace import mutter
47
47
from bzrlib.transport import remote
48
48
 
49
49
 
53
53
                                *func_args, **func_kwargs):
54
54
        """Run 'bzr serve', and run the given func in a thread once the server
55
55
        has started.
56
 
 
 
56
        
57
57
        When 'func' terminates, the server will be terminated too.
58
 
 
 
58
        
59
59
        Returns stdout and stderr.
60
60
        """
 
61
        # install hook
 
62
        def on_server_start(backing_urls, tcp_server):
 
63
            t = threading.Thread(
 
64
                target=on_server_start_thread, args=(tcp_server,))
 
65
            t.start()
61
66
        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
 
            """
67
67
            try:
68
68
                # Run func if set
69
69
                self.tcp_server = tcp_server
70
 
                if func is not None:
 
70
                if not func is None:
71
71
                    try:
72
72
                        func(*func_args, **func_kwargs)
73
73
                    except Exception, e:
74
74
                        # Log errors to make some test failures a little less
75
75
                        # mysterious.
76
 
                        trace.mutter('func broke: %r', e)
 
76
                        mutter('func broke: %r', e)
77
77
            finally:
78
78
                # Then stop the server
79
 
                trace.mutter('interrupting...')
 
79
                mutter('interrupting...')
80
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
88
81
        SmartTCPServer.hooks.install_named_hook(
89
82
            'server_started_ex', on_server_start,
90
83
            '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)
95
84
        # start a TCP server
96
85
        try:
97
 
            out, err = self.run_bzr(['serve'] + list(serve_args),
98
 
                                    retcode=retcode)
 
86
            out, err = self.run_bzr(['serve'] + list(serve_args))
99
87
        except KeyboardInterrupt, e:
100
88
            out, err = e.args
101
89
        return out, err
107
95
        super(TestBzrServe, self).setUp()
108
96
        self.disable_missing_extensions_warning()
109
97
 
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 = ['--port', 'localhost: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
 
 
134
98
    def assertInetServerShutsdownCleanly(self, process):
135
99
        """Shutdown the server process looking for errors."""
136
100
        # Shutdown the server: the server should shut down when it cannot read
200
164
        url = 'bzr://localhost:%d/' % port
201
165
        self.permit_url(url)
202
166
        return process, url
203
 
 
 
167
    
204
168
    def test_bzr_serve_quiet(self):
205
169
        self.make_branch('.')
206
170
        args = ['--port', 'localhost:0', '--quiet']
229
193
    def test_bzr_serve_port_readonly(self):
230
194
        """bzr server should provide a read only filesystem by default."""
231
195
        process, url = self.start_server_port()
232
 
        t = transport.get_transport_from_url(url)
 
196
        t = transport.get_transport(url)
233
197
        self.assertRaises(errors.TransportNotPossible, t.mkdir, 'adir')
234
198
        self.assertServerFinishesCleanly(process)
235
199
 
261
225
        # -Dhpss, and does drop some hpss logging to the file.
262
226
        self.make_branch('.')
263
227
        log_fname = os.getcwd() + '/server.log'
264
 
        self.overrideEnv('BZR_LOG', log_fname)
 
228
        self._captureVar('BZR_LOG', log_fname)
265
229
        process, transport = self.start_server_inet(['-Dhpss'])
266
230
        branch = BzrDir.open_from_transport(transport).open_branch()
267
231
        self.make_read_requests(branch)
271
235
        f.close()
272
236
        self.assertContainsRe(content, r'hpss request: \[[0-9-]+\]')
273
237
 
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
 
 
344
238
 
345
239
class TestCmdServeChrooting(TestBzrServeBase):
346
240
 
382
276
 
383
277
class TestUserdirExpansion(TestCaseWithMemoryTransport):
384
278
 
385
 
    @staticmethod
386
 
    def fake_expanduser(path):
 
279
    def fake_expanduser(self, path):
387
280
        """A simple, environment-independent, function for the duration of this
388
281
        test.
389
282
 
402
295
            self.fake_expanduser, lambda t: base_path)
403
296
        mem_transport = self.get_transport()
404
297
        mem_transport.mkdir_multi(['home', 'home/user'])
405
 
        bzr_server.set_up(mem_transport, None, None, inet=True, timeout=4.0)
 
298
        bzr_server.set_up(mem_transport, None, None, inet=True)
406
299
        self.addCleanup(bzr_server.tear_down)
407
300
        return bzr_server
408
301
 
424
317
        base_url = urlutils.local_path_to_url(base_dir) + '/'
425
318
        # Define a fake 'protocol' to capture the transport that cmd_serve
426
319
        # passes to serve_bzr.
427
 
        def capture_transport(transport, host, port, inet, timeout):
 
320
        def capture_transport(transport, host, port, inet):
428
321
            self.bzr_serve_transport = transport
429
322
        cmd = builtins.cmd_serve()
430
323
        # Read-only
441
334
        self.assertEqual(base_url, self.bzr_serve_transport.base)
442
335
        self.assertEqual(base_dir,
443
336
            server_maker.get_base_path(self.bzr_serve_transport))
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))
 
337