/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

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

  • Committer: Jelmer Vernooij
  • Date: 2018-02-18 21:42:57 UTC
  • mto: This revision was merged to the branch mainline in revision 6859.
  • Revision ID: jelmer@jelmer.uk-20180218214257-jpevutp1wa30tz3v
Update TODO to reference Breezy, not Bazaar.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/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
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
18
 
"""Tests of the bzr serve command."""
 
18
"""Tests of the brz 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
 
from bzrlib import (
 
26
from ... 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
 
from bzrlib.branch import Branch
37
 
from bzrlib.bzrdir import BzrDir
38
 
from bzrlib.smart import client, medium
39
 
from bzrlib.smart.server import BzrServerFactory, SmartTCPServer
40
 
from bzrlib.tests import (
 
36
from ...branch import Branch
 
37
from ...controldir import ControlDir
 
38
from ...bzr.smart import client, medium
 
39
from ...bzr.smart.server import (
 
40
    BzrServerFactory,
 
41
    SmartTCPServer,
 
42
    )
 
43
from .. 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 ...transport import remote
47
48
 
48
49
 
49
50
class TestBzrServeBase(TestCaseWithTransport):
50
51
 
51
52
    def run_bzr_serve_then_func(self, serve_args, retcode=0, func=None,
52
53
                                *func_args, **func_kwargs):
53
 
        """Run 'bzr serve', and run the given func in a thread once the server
 
54
        """Run 'brz 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
 
                    except Exception, e:
 
73
                    except Exception as 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))
86
 
        except KeyboardInterrupt, e:
87
 
            out, err = e.args
 
97
            out, err = self.run_bzr(['serve'] + list(serve_args),
 
98
                                    retcode=retcode)
 
99
        except KeyboardInterrupt as e:
 
100
            return (self._last_cmd_stdout.getvalue(),
 
101
                self._last_cmd_stderr.getvalue())
88
102
        return out, err
89
103
 
90
104
 
94
108
        super(TestBzrServe, self).setUp()
95
109
        self.disable_missing_extensions_warning()
96
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 = ['--listen', 'localhost', '--port', '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
 
97
135
    def assertInetServerShutsdownCleanly(self, process):
98
136
        """Shutdown the server process looking for errors."""
99
137
        # Shutdown the server: the server should shut down when it cannot read
106
144
        self.assertEqual('', result[1])
107
145
 
108
146
    def assertServerFinishesCleanly(self, process):
109
 
        """Shutdown the bzr serve instance process looking for errors."""
 
147
        """Shutdown the brz serve instance process looking for errors."""
110
148
        # Shutdown the server
111
149
        result = self.finish_bzr_subprocess(process, retcode=3,
112
150
                                            send_signal=signal.SIGINT)
113
151
        self.assertEqual('', result[0])
114
 
        self.assertEqual('bzr: interrupted\n', result[1])
 
152
        self.assertEqual('brz: interrupted\n', result[1])
115
153
 
116
154
    def make_read_requests(self, branch):
117
155
        """Do some read only requests."""
118
 
        branch.lock_read()
119
 
        try:
 
156
        with branch.lock_read():
120
157
            branch.repository.all_revision_ids()
121
158
            self.assertEqual(_mod_revision.NULL_REVISION,
122
159
                             _mod_revision.ensure_null(branch.last_revision()))
123
 
        finally:
124
 
            branch.unlock()
125
160
 
126
161
    def start_server_inet(self, extra_options=()):
127
 
        """Start a bzr server subprocess using the --inet option.
 
162
        """Start a brz server subprocess using the --inet option.
128
163
 
129
164
        :param extra_options: extra options to give the server.
130
 
        :return: a tuple with the bzr process handle for passing to
 
165
        :return: a tuple with the brz process handle for passing to
131
166
            finish_bzr_subprocess, a client for the server, and a transport.
132
167
        """
133
168
        # Serve from the current directory
146
181
        return process, transport
147
182
 
148
183
    def start_server_port(self, extra_options=()):
149
 
        """Start a bzr server subprocess.
 
184
        """Start a brz server subprocess.
150
185
 
151
186
        :param extra_options: extra options to give the server.
152
 
        :return: a tuple with the bzr process handle for passing to
 
187
        :return: a tuple with the brz process handle for passing to
153
188
            finish_bzr_subprocess, and the base url for the server.
154
189
        """
155
190
        # Serve from the current directory
156
 
        args = ['serve', '--port', 'localhost:0']
 
191
        args = ['serve', '--listen', 'localhost', '--port', '0']
157
192
        args.extend(extra_options)
158
193
        process = self.start_bzr_subprocess(args, skip_if_plan_to_signal=True)
159
194
        port_line = process.stderr.readline()
163
198
        url = 'bzr://localhost:%d/' % port
164
199
        self.permit_url(url)
165
200
        return process, url
166
 
    
 
201
 
167
202
    def test_bzr_serve_quiet(self):
168
203
        self.make_branch('.')
169
 
        args = ['--port', 'localhost:0', '--quiet']
 
204
        args = ['--listen', 'localhost', '--port', '0', '--quiet']
170
205
        out, err = self.run_bzr_serve_then_func(args, retcode=3)
171
206
        self.assertEqual('', out)
172
207
        self.assertEqual('', err)
173
208
 
174
209
    def test_bzr_serve_inet_readonly(self):
175
 
        """bzr server should provide a read only filesystem by default."""
 
210
        """brz server should provide a read only filesystem by default."""
176
211
        process, transport = self.start_server_inet()
177
212
        self.assertRaises(errors.TransportNotPossible, transport.mkdir, 'adir')
178
213
        self.assertInetServerShutsdownCleanly(process)
184
219
        process, transport = self.start_server_inet(['--allow-writes'])
185
220
 
186
221
        # We get a working branch, and can create a directory
187
 
        branch = BzrDir.open_from_transport(transport).open_branch()
 
222
        branch = ControlDir.open_from_transport(transport).open_branch()
188
223
        self.make_read_requests(branch)
189
224
        transport.mkdir('adir')
190
225
        self.assertInetServerShutsdownCleanly(process)
191
226
 
192
227
    def test_bzr_serve_port_readonly(self):
193
 
        """bzr server should provide a read only filesystem by default."""
 
228
        """brz server should provide a read only filesystem by default."""
194
229
        process, url = self.start_server_port()
195
 
        transport = get_transport(url)
196
 
        self.assertRaises(errors.TransportNotPossible, transport.mkdir, 'adir')
 
230
        t = transport.get_transport_from_url(url)
 
231
        self.assertRaises(errors.TransportNotPossible, t.mkdir, 'adir')
197
232
        self.assertServerFinishesCleanly(process)
198
233
 
199
234
    def test_bzr_serve_port_readwrite(self):
223
258
        # This is a smoke test that the server doesn't crash when run with
224
259
        # -Dhpss, and does drop some hpss logging to the file.
225
260
        self.make_branch('.')
226
 
        log_fname = os.getcwd() + '/server.log'
227
 
        self._captureVar('BZR_LOG', log_fname)
 
261
        log_fname = self.test_dir + '/server.log'
 
262
        self.overrideEnv('BRZ_LOG', log_fname)
228
263
        process, transport = self.start_server_inet(['-Dhpss'])
229
 
        branch = BzrDir.open_from_transport(transport).open_branch()
 
264
        branch = ControlDir.open_from_transport(transport).open_branch()
230
265
        self.make_read_requests(branch)
231
266
        self.assertInetServerShutsdownCleanly(process)
232
267
        f = open(log_fname, 'rb')
234
269
        f.close()
235
270
        self.assertContainsRe(content, r'hpss request: \[[0-9-]+\]')
236
271
 
 
272
    def test_bzr_serve_supports_configurable_timeout(self):
 
273
        gs = config.GlobalStack()
 
274
        gs.set('serve.client_timeout', 0.2)
 
275
        # Save the config as the subprocess will use it
 
276
        gs.store.save()
 
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
        m = t.get_smart_medium()
 
285
        m.read_bytes(1)
 
286
        # Now, we wait for timeout to trigger
 
287
        err = process.stderr.readline()
 
288
        self.assertEqual(
 
289
            'Connection Timeout: disconnecting client after 0.2 seconds\n',
 
290
            err)
 
291
        self.assertServerFinishesCleanly(process)
 
292
 
 
293
    def test_bzr_serve_supports_client_timeout(self):
 
294
        process, url = self.start_server_port(['--client-timeout=0.1'])
 
295
        self.build_tree_contents([('a_file', 'contents\n')])
 
296
        # We can connect and issue a request
 
297
        t = transport.get_transport_from_url(url)
 
298
        self.assertEqual('contents\n', t.get_bytes('a_file'))
 
299
        # However, if we just wait for more content from the server, it will
 
300
        # eventually disconnect us.
 
301
        # TODO: Use something like signal.alarm() so that if the server doesn't
 
302
        #       properly handle the timeout, we end up failing the test instead
 
303
        #       of hanging forever.
 
304
        m = t.get_smart_medium()
 
305
        m.read_bytes(1)
 
306
        # Now, we wait for timeout to trigger
 
307
        err = process.stderr.readline()
 
308
        self.assertEqual(
 
309
            'Connection Timeout: disconnecting client after 0.1 seconds\n',
 
310
            err)
 
311
        self.assertServerFinishesCleanly(process)
 
312
 
 
313
    def test_bzr_serve_graceful_shutdown(self):
 
314
        big_contents = 'a'*64*1024
 
315
        self.build_tree_contents([('bigfile', big_contents)])
 
316
        process, url = self.start_server_port(['--client-timeout=1.0'])
 
317
        t = transport.get_transport_from_url(url)
 
318
        m = t.get_smart_medium()
 
319
        c = client._SmartClient(m)
 
320
        # Start, but don't finish a response
 
321
        resp, response_handler = c.call_expecting_body('get', 'bigfile')
 
322
        self.assertEqual(('ok',), resp)
 
323
        # Note: process.send_signal is a Python 2.6ism
 
324
        process.send_signal(signal.SIGHUP)
 
325
        # Wait for the server to notice the signal, and then read the actual
 
326
        # body of the response. That way we know that it is waiting for the
 
327
        # request to finish
 
328
        self.assertEqual('Requested to stop gracefully\n',
 
329
                         process.stderr.readline())
 
330
        self.assertEqual('Waiting for 1 client(s) to finish\n',
 
331
                         process.stderr.readline())
 
332
        body = response_handler.read_body_bytes()
 
333
        if body != big_contents:
 
334
            self.fail('Failed to properly read the contents of "bigfile"')
 
335
        # Now that our request is finished, the medium should notice it has
 
336
        # been disconnected.
 
337
        self.assertEqual('', m.read_bytes(1))
 
338
        # And the server should be stopping
 
339
        self.assertEqual(0, process.wait())
 
340
 
237
341
 
238
342
class TestCmdServeChrooting(TestBzrServeBase):
239
343
 
240
344
    def test_serve_tcp(self):
241
 
        """'bzr serve' wraps the given --directory in a ChrootServer.
 
345
        """'brz serve' wraps the given --directory in a ChrootServer.
242
346
 
243
347
        So requests that search up through the parent directories (like
244
348
        find_repositoryV3) will give "not found" responses, rather than
247
351
        t = self.get_transport()
248
352
        t.mkdir('server-root')
249
353
        self.run_bzr_serve_then_func(
250
 
            ['--port', '127.0.0.1:0',
 
354
            ['--listen', '127.0.0.1', '--port', '0',
251
355
             '--directory', t.local_abspath('server-root'),
252
356
             '--allow-writes'],
253
357
            func=self.when_server_started)
267
371
        resp = smart_client.call('BzrDirFormat.initialize', 'foo/')
268
372
        try:
269
373
            resp = smart_client.call('BzrDir.find_repositoryV3', 'foo/')
270
 
        except errors.ErrorFromSmartServer, e:
 
374
        except errors.ErrorFromSmartServer as e:
271
375
            resp = e.error_tuple
272
376
        self.client_resp = resp
273
377
        client_medium.disconnect()
275
379
 
276
380
class TestUserdirExpansion(TestCaseWithMemoryTransport):
277
381
 
278
 
    def fake_expanduser(self, path):
 
382
    @staticmethod
 
383
    def fake_expanduser(path):
279
384
        """A simple, environment-independent, function for the duration of this
280
385
        test.
281
386
 
294
399
            self.fake_expanduser, lambda t: base_path)
295
400
        mem_transport = self.get_transport()
296
401
        mem_transport.mkdir_multi(['home', 'home/user'])
297
 
        bzr_server.set_up(mem_transport, None, None, inet=True)
 
402
        bzr_server.set_up(mem_transport, None, None, inet=True, timeout=4.0)
298
403
        self.addCleanup(bzr_server.tear_down)
299
404
        return bzr_server
300
405
 
316
421
        base_url = urlutils.local_path_to_url(base_dir) + '/'
317
422
        # Define a fake 'protocol' to capture the transport that cmd_serve
318
423
        # passes to serve_bzr.
319
 
        def capture_transport(transport, host, port, inet):
 
424
        def capture_transport(transport, host, port, inet, timeout):
320
425
            self.bzr_serve_transport = transport
321
426
        cmd = builtins.cmd_serve()
322
427
        # Read-only
333
438
        self.assertEqual(base_url, self.bzr_serve_transport.base)
334
439
        self.assertEqual(base_dir,
335
440
            server_maker.get_base_path(self.bzr_serve_transport))
336
 
 
 
441
        # Read-only, from a URL
 
442
        cmd.run(directory=base_url, protocol=capture_transport)
 
443
        server_maker = BzrServerFactory()
 
444
        self.assertEqual(
 
445
            'readonly+%s' % base_url, self.bzr_serve_transport.base)
 
446
        self.assertEqual(
 
447
            base_dir, server_maker.get_base_path(self.bzr_serve_transport))