← 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: Martin
  • Date: 2010-05-03 20:57:39 UTC
  • mto: This revision was merged to the branch mainline in revision 5204.
  • Revision ID: gzlist@googlemail.com-20100503205739-n326zdvevv0rmruh
Retain original stack and error message when translating to ValueError in bencode

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