← 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: Patch Queue Manager
  • Date: 2011-10-14 16:54:26 UTC
  • mfrom: (6216.1.1 remove-this-file)
  • Revision ID: pqm@pqm.ubuntu.com-20111014165426-tjix4e6idryf1r2z
(jelmer) Remove an accidentally committed .THIS file. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

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