/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: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2020-08-23 01:15:41 UTC
  • mfrom: (7520.1.4 merge-3.1)
  • Revision ID: breezy.the.bot@gmail.com-20200823011541-nv0oh7nzaganx2qy
Merge lp:brz/3.1.

Merged from https://code.launchpad.net/~jelmer/brz/merge-3.1/+merge/389690

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
 
import thread
 
23
from _thread import interrupt_main
 
24
 
26
25
import threading
27
26
 
28
 
from bzrlib import (
 
27
from ... import (
29
28
    builtins,
30
 
    debug,
 
29
    config,
31
30
    errors,
32
31
    osutils,
33
32
    revision as _mod_revision,
 
33
    trace,
 
34
    transport,
34
35
    urlutils,
35
36
    )
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 (
 
37
from ...branch import Branch
 
38
from ...controldir import ControlDir
 
39
from ...bzr.smart import client, medium
 
40
from ...bzr.smart.server import (
 
41
    BzrServerFactory,
 
42
    SmartTCPServer,
 
43
    )
 
44
from .. import (
41
45
    TestCaseWithMemoryTransport,
42
46
    TestCaseWithTransport,
43
 
    TestSkipped,
44
47
    )
45
 
from bzrlib.trace import mutter
46
 
from bzrlib.transport import get_transport, remote
 
48
from ...transport import remote
47
49
 
48
50
 
49
51
class TestBzrServeBase(TestCaseWithTransport):
50
52
 
51
53
    def run_bzr_serve_then_func(self, serve_args, retcode=0, func=None,
52
54
                                *func_args, **func_kwargs):
53
 
        """Run 'bzr serve', and run the given func in a thread once the server
 
55
        """Run 'brz serve', and run the given func in a thread once the server
54
56
        has started.
55
 
        
 
57
 
56
58
        When 'func' terminates, the server will be terminated too.
57
 
        
 
59
 
58
60
        Returns stdout and stderr.
59
61
        """
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
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
            """
66
68
            try:
67
69
                # Run func if set
68
70
                self.tcp_server = tcp_server
69
 
                if not func is None:
 
71
                if func is not None:
70
72
                    try:
71
73
                        func(*func_args, **func_kwargs)
72
 
                    except Exception, e:
 
74
                    except Exception as e:
73
75
                        # Log errors to make some test failures a little less
74
76
                        # mysterious.
75
 
                        mutter('func broke: %r', e)
 
77
                        trace.mutter('func broke: %r', e)
76
78
            finally:
77
79
                # Then stop the server
78
 
                mutter('interrupting...')
79
 
                thread.interrupt_main()
 
80
                trace.mutter('interrupting...')
 
81
                interrupt_main()
 
82
        # When the hook is fired, it just starts ``on_server_start_thread`` and
 
83
        # return
 
84
 
 
85
        def on_server_start(backing_urls, tcp_server):
 
86
            t = threading.Thread(
 
87
                target=on_server_start_thread, args=(tcp_server,))
 
88
            t.start()
 
89
        # install hook
80
90
        SmartTCPServer.hooks.install_named_hook(
81
91
            'server_started_ex', on_server_start,
82
92
            'run_bzr_serve_then_func hook')
 
93
        # It seems interrupt_main() will not raise KeyboardInterrupt
 
94
        # until after socket.accept returns. So we set the timeout low to make
 
95
        # the test faster.
 
96
        self.overrideAttr(SmartTCPServer, '_ACCEPT_TIMEOUT', 0.1)
83
97
        # start a TCP server
84
98
        try:
85
 
            out, err = self.run_bzr(['serve'] + list(serve_args))
86
 
        except KeyboardInterrupt, e:
87
 
            out, err = e.args
 
99
            out, err = self.run_bzr(['serve'] + list(serve_args),
 
100
                                    retcode=retcode)
 
101
        except KeyboardInterrupt as e:
 
102
            return (self._last_cmd_stdout.getvalue(),
 
103
                    self._last_cmd_stderr.getvalue())
88
104
        return out, err
89
105
 
90
106
 
94
110
        super(TestBzrServe, self).setUp()
95
111
        self.disable_missing_extensions_warning()
96
112
 
 
113
    def test_server_exception_with_hook(self):
 
114
        """Catch exception from the server in the server_exception hook.
 
115
 
 
116
        We use ``run_bzr_serve_then_func`` without a ``func`` so the server
 
117
        will receive a KeyboardInterrupt exception we want to catch.
 
118
        """
 
119
        def hook(exception):
 
120
            if exception[0] is KeyboardInterrupt:
 
121
                sys.stderr.write(b'catching KeyboardInterrupt\n')
 
122
                return True
 
123
            else:
 
124
                return False
 
125
        SmartTCPServer.hooks.install_named_hook(
 
126
            'server_exception', hook,
 
127
            'test_server_except_hook hook')
 
128
        args = ['--listen', 'localhost', '--port', '0', '--quiet']
 
129
        out, err = self.run_bzr_serve_then_func(args, retcode=0)
 
130
        self.assertEqual('catching KeyboardInterrupt\n', err)
 
131
 
 
132
    def test_server_exception_no_hook(self):
 
133
        """test exception without hook returns error"""
 
134
        args = []
 
135
        out, err = self.run_bzr_serve_then_func(args, retcode=3)
 
136
 
97
137
    def assertInetServerShutsdownCleanly(self, process):
98
138
        """Shutdown the server process looking for errors."""
99
139
        # Shutdown the server: the server should shut down when it cannot read
102
142
        # Hide stdin from the subprocess module, so it won't fail to close it.
103
143
        process.stdin = None
104
144
        result = self.finish_bzr_subprocess(process)
105
 
        self.assertEqual('', result[0])
106
 
        self.assertEqual('', result[1])
 
145
        self.assertEqual(b'', result[0])
 
146
        self.assertEqual(b'', result[1])
107
147
 
108
148
    def assertServerFinishesCleanly(self, process):
109
 
        """Shutdown the bzr serve instance process looking for errors."""
 
149
        """Shutdown the brz serve instance process looking for errors."""
110
150
        # Shutdown the server
111
151
        result = self.finish_bzr_subprocess(process, retcode=3,
112
152
                                            send_signal=signal.SIGINT)
113
 
        self.assertEqual('', result[0])
114
 
        self.assertEqual('bzr: interrupted\n', result[1])
 
153
        self.assertEqual(b'', result[0])
 
154
        self.assertEqual(b'brz: interrupted\n', result[1])
115
155
 
116
156
    def make_read_requests(self, branch):
117
157
        """Do some read only requests."""
118
 
        branch.lock_read()
119
 
        try:
 
158
        with branch.lock_read():
120
159
            branch.repository.all_revision_ids()
121
160
            self.assertEqual(_mod_revision.NULL_REVISION,
122
161
                             _mod_revision.ensure_null(branch.last_revision()))
123
 
        finally:
124
 
            branch.unlock()
125
162
 
126
163
    def start_server_inet(self, extra_options=()):
127
 
        """Start a bzr server subprocess using the --inet option.
 
164
        """Start a brz server subprocess using the --inet option.
128
165
 
129
166
        :param extra_options: extra options to give the server.
130
 
        :return: a tuple with the bzr process handle for passing to
 
167
        :return: a tuple with the brz process handle for passing to
131
168
            finish_bzr_subprocess, a client for the server, and a transport.
132
169
        """
133
170
        # Serve from the current directory
146
183
        return process, transport
147
184
 
148
185
    def start_server_port(self, extra_options=()):
149
 
        """Start a bzr server subprocess.
 
186
        """Start a brz server subprocess.
150
187
 
151
188
        :param extra_options: extra options to give the server.
152
 
        :return: a tuple with the bzr process handle for passing to
 
189
        :return: a tuple with the brz process handle for passing to
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()
160
 
        prefix = 'listening on port: '
 
197
        prefix = b'listening on port: '
161
198
        self.assertStartsWith(port_line, prefix)
162
199
        port = int(port_line[len(prefix):])
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)
173
210
 
174
211
    def test_bzr_serve_inet_readonly(self):
175
 
        """bzr server should provide a read only filesystem by default."""
 
212
        """brz server should provide a read only filesystem by default."""
176
213
        process, transport = self.start_server_inet()
177
214
        self.assertRaises(errors.TransportNotPossible, transport.mkdir, 'adir')
178
215
        self.assertInetServerShutsdownCleanly(process)
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)
191
228
 
192
229
    def test_bzr_serve_port_readonly(self):
193
 
        """bzr server should provide a read only filesystem by default."""
 
230
        """brz 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):
223
260
        # This is a smoke test that the server doesn't crash when run with
224
261
        # -Dhpss, and does drop some hpss logging to the file.
225
262
        self.make_branch('.')
226
 
        log_fname = os.getcwd() + '/server.log'
227
 
        self._captureVar('BZR_LOG', log_fname)
 
263
        log_fname = self.test_dir + '/server.log'
 
264
        self.overrideEnv('BRZ_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')
233
270
        content = f.read()
234
271
        f.close()
235
 
        self.assertContainsRe(content, r'hpss request: \[[0-9-]+\]')
 
272
        self.assertContainsRe(content, br'hpss request: \[[0-9-]+\]')
 
273
 
 
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', b'contents\n')])
 
281
        # We can connect and issue a request
 
282
        t = transport.get_transport_from_url(url)
 
283
        self.assertEqual(b'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
            b'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', b'contents\n')])
 
298
        # We can connect and issue a request
 
299
        t = transport.get_transport_from_url(url)
 
300
        self.assertEqual(b'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
            b'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 = b'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(b'get', b'bigfile')
 
324
        self.assertEqual((b'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(b'Requested to stop gracefully\n',
 
331
                         process.stderr.readline())
 
332
        self.assertIn(process.stderr.readline(),
 
333
                      (b'', b'Waiting for 1 client(s) to finish\n'))
 
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(b'', m.read_bytes(1))
 
340
        # And the server should be stopping
 
341
        self.assertEqual(0, process.wait())
236
342
 
237
343
 
238
344
class TestCmdServeChrooting(TestBzrServeBase):
239
345
 
240
346
    def test_serve_tcp(self):
241
 
        """'bzr serve' wraps the given --directory in a ChrootServer.
 
347
        """'brz serve' wraps the given --directory in a ChrootServer.
242
348
 
243
349
        So requests that search up through the parent directories (like
244
350
        find_repositoryV3) will give "not found" responses, rather than
247
353
        t = self.get_transport()
248
354
        t.mkdir('server-root')
249
355
        self.run_bzr_serve_then_func(
250
 
            ['--port', '127.0.0.1:0',
 
356
            ['--listen', '127.0.0.1', '--port', '0',
251
357
             '--directory', t.local_abspath('server-root'),
252
358
             '--allow-writes'],
253
359
            func=self.when_server_started)
254
360
        # The when_server_started method issued a find_repositoryV3 that should
255
361
        # fail with 'norepository' because there are no repositories inside the
256
362
        # --directory.
257
 
        self.assertEqual(('norepository',), self.client_resp)
 
363
        self.assertEqual((b'norepository',), self.client_resp)
258
364
 
259
365
    def when_server_started(self):
260
366
        # Connect to the TCP server and issue some requests and see what comes
267
373
        resp = smart_client.call('BzrDirFormat.initialize', 'foo/')
268
374
        try:
269
375
            resp = smart_client.call('BzrDir.find_repositoryV3', 'foo/')
270
 
        except errors.ErrorFromSmartServer, e:
 
376
        except errors.ErrorFromSmartServer as e:
271
377
            resp = e.error_tuple
272
378
        self.client_resp = resp
273
379
        client_medium.disconnect()
275
381
 
276
382
class TestUserdirExpansion(TestCaseWithMemoryTransport):
277
383
 
278
 
    def fake_expanduser(self, path):
 
384
    @staticmethod
 
385
    def fake_expanduser(path):
279
386
        """A simple, environment-independent, function for the duration of this
280
387
        test.
281
388
 
293
400
        bzr_server = BzrServerFactory(
294
401
            self.fake_expanduser, lambda t: base_path)
295
402
        mem_transport = self.get_transport()
296
 
        mem_transport.mkdir_multi(['home', 'home/user'])
297
 
        bzr_server.set_up(mem_transport, None, None, inet=True)
 
403
        mem_transport.mkdir('home')
 
404
        mem_transport.mkdir('home/user')
 
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
 
304
412
 
305
413
    def test_bzr_serve_does_not_expand_userdir_outside_base(self):
306
414
        bzr_server = self.make_test_server('/foo')
307
 
        self.assertFalse(bzr_server.smart_server.backing_transport.has('~user'))
 
415
        self.assertFalse(
 
416
            bzr_server.smart_server.backing_transport.has('~user'))
308
417
 
309
418
    def test_get_base_path(self):
310
419
        """cmd_serve will turn the --directory option into a LocalTransport
316
425
        base_url = urlutils.local_path_to_url(base_dir) + '/'
317
426
        # Define a fake 'protocol' to capture the transport that cmd_serve
318
427
        # passes to serve_bzr.
319
 
        def capture_transport(transport, host, port, inet):
 
428
 
 
429
        def capture_transport(transport, host, port, inet, timeout):
320
430
            self.bzr_serve_transport = transport
321
431
        cmd = builtins.cmd_serve()
322
432
        # Read-only
328
438
            base_dir, server_maker.get_base_path(self.bzr_serve_transport))
329
439
        # Read-write
330
440
        cmd.run(directory=base_dir, protocol=capture_transport,
331
 
            allow_writes=True)
 
441
                allow_writes=True)
332
442
        server_maker = BzrServerFactory()
333
443
        self.assertEqual(base_url, self.bzr_serve_transport.base)
334
444
        self.assertEqual(base_dir,
335
 
            server_maker.get_base_path(self.bzr_serve_transport))
336
 
 
 
445
                         server_maker.get_base_path(self.bzr_serve_transport))
 
446
        # Read-only, from a URL
 
447
        cmd.run(directory=base_url, protocol=capture_transport)
 
448
        server_maker = BzrServerFactory()
 
449
        self.assertEqual(
 
450
            'readonly+%s' % base_url, self.bzr_serve_transport.base)
 
451
        self.assertEqual(
 
452
            base_dir, server_maker.get_base_path(self.bzr_serve_transport))