/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: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

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
try:
 
24
    from _thread import interrupt_main
 
25
except ImportError:  # Python < 3
 
26
    from thread import interrupt_main
 
27
 
26
28
import threading
27
29
 
28
 
from bzrlib import (
 
30
from ... import (
29
31
    builtins,
30
 
    debug,
 
32
    config,
31
33
    errors,
32
34
    osutils,
33
35
    revision as _mod_revision,
 
36
    trace,
 
37
    transport,
34
38
    urlutils,
35
39
    )
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 (
 
40
from ...branch import Branch
 
41
from ...controldir import ControlDir
 
42
from ...bzr.smart import client, medium
 
43
from ...bzr.smart.server import (
 
44
    BzrServerFactory,
 
45
    SmartTCPServer,
 
46
    )
 
47
from .. import (
41
48
    TestCaseWithMemoryTransport,
42
49
    TestCaseWithTransport,
43
 
    TestSkipped,
44
50
    )
45
 
from bzrlib.trace import mutter
46
 
from bzrlib.transport import get_transport, remote
 
51
from ...transport import remote
47
52
 
48
53
 
49
54
class TestBzrServeBase(TestCaseWithTransport):
50
55
 
51
56
    def run_bzr_serve_then_func(self, serve_args, retcode=0, func=None,
52
57
                                *func_args, **func_kwargs):
53
 
        """Run 'bzr serve', and run the given func in a thread once the server
 
58
        """Run 'brz serve', and run the given func in a thread once the server
54
59
        has started.
55
 
        
 
60
 
56
61
        When 'func' terminates, the server will be terminated too.
57
 
        
 
62
 
58
63
        Returns stdout and stderr.
59
64
        """
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
65
        def on_server_start_thread(tcp_server):
 
66
            """This runs concurrently with the server thread.
 
67
 
 
68
            The server is interrupted as soon as ``func`` finishes, even if an
 
69
            exception is encountered.
 
70
            """
66
71
            try:
67
72
                # Run func if set
68
73
                self.tcp_server = tcp_server
69
 
                if not func is None:
 
74
                if func is not None:
70
75
                    try:
71
76
                        func(*func_args, **func_kwargs)
72
 
                    except Exception, e:
 
77
                    except Exception as e:
73
78
                        # Log errors to make some test failures a little less
74
79
                        # mysterious.
75
 
                        mutter('func broke: %r', e)
 
80
                        trace.mutter('func broke: %r', e)
76
81
            finally:
77
82
                # Then stop the server
78
 
                mutter('interrupting...')
79
 
                thread.interrupt_main()
 
83
                trace.mutter('interrupting...')
 
84
                interrupt_main()
 
85
        # When the hook is fired, it just starts ``on_server_start_thread`` and
 
86
        # return
 
87
 
 
88
        def on_server_start(backing_urls, tcp_server):
 
89
            t = threading.Thread(
 
90
                target=on_server_start_thread, args=(tcp_server,))
 
91
            t.start()
 
92
        # install hook
80
93
        SmartTCPServer.hooks.install_named_hook(
81
94
            'server_started_ex', on_server_start,
82
95
            'run_bzr_serve_then_func hook')
 
96
        # It seems interrupt_main() will not raise KeyboardInterrupt
 
97
        # until after socket.accept returns. So we set the timeout low to make
 
98
        # the test faster.
 
99
        self.overrideAttr(SmartTCPServer, '_ACCEPT_TIMEOUT', 0.1)
83
100
        # start a TCP server
84
101
        try:
85
 
            out, err = self.run_bzr(['serve'] + list(serve_args))
86
 
        except KeyboardInterrupt, e:
87
 
            out, err = e.args
 
102
            out, err = self.run_bzr(['serve'] + list(serve_args),
 
103
                                    retcode=retcode)
 
104
        except KeyboardInterrupt as e:
 
105
            return (self._last_cmd_stdout.getvalue(),
 
106
                    self._last_cmd_stderr.getvalue())
88
107
        return out, err
89
108
 
90
109
 
94
113
        super(TestBzrServe, self).setUp()
95
114
        self.disable_missing_extensions_warning()
96
115
 
 
116
    def test_server_exception_with_hook(self):
 
117
        """Catch exception from the server in the server_exception hook.
 
118
 
 
119
        We use ``run_bzr_serve_then_func`` without a ``func`` so the server
 
120
        will receive a KeyboardInterrupt exception we want to catch.
 
121
        """
 
122
        def hook(exception):
 
123
            if exception[0] is KeyboardInterrupt:
 
124
                sys.stderr.write(b'catching KeyboardInterrupt\n')
 
125
                return True
 
126
            else:
 
127
                return False
 
128
        SmartTCPServer.hooks.install_named_hook(
 
129
            'server_exception', hook,
 
130
            'test_server_except_hook hook')
 
131
        args = ['--listen', 'localhost', '--port', '0', '--quiet']
 
132
        out, err = self.run_bzr_serve_then_func(args, retcode=0)
 
133
        self.assertEqual('catching KeyboardInterrupt\n', err)
 
134
 
 
135
    def test_server_exception_no_hook(self):
 
136
        """test exception without hook returns error"""
 
137
        args = []
 
138
        out, err = self.run_bzr_serve_then_func(args, retcode=3)
 
139
 
97
140
    def assertInetServerShutsdownCleanly(self, process):
98
141
        """Shutdown the server process looking for errors."""
99
142
        # Shutdown the server: the server should shut down when it cannot read
102
145
        # Hide stdin from the subprocess module, so it won't fail to close it.
103
146
        process.stdin = None
104
147
        result = self.finish_bzr_subprocess(process)
105
 
        self.assertEqual('', result[0])
106
 
        self.assertEqual('', result[1])
 
148
        self.assertEqual(b'', result[0])
 
149
        self.assertEqual(b'', result[1])
107
150
 
108
151
    def assertServerFinishesCleanly(self, process):
109
 
        """Shutdown the bzr serve instance process looking for errors."""
 
152
        """Shutdown the brz serve instance process looking for errors."""
110
153
        # Shutdown the server
111
154
        result = self.finish_bzr_subprocess(process, retcode=3,
112
155
                                            send_signal=signal.SIGINT)
113
 
        self.assertEqual('', result[0])
114
 
        self.assertEqual('bzr: interrupted\n', result[1])
 
156
        self.assertEqual(b'', result[0])
 
157
        self.assertEqual(b'brz: interrupted\n', result[1])
115
158
 
116
159
    def make_read_requests(self, branch):
117
160
        """Do some read only requests."""
118
 
        branch.lock_read()
119
 
        try:
 
161
        with branch.lock_read():
120
162
            branch.repository.all_revision_ids()
121
163
            self.assertEqual(_mod_revision.NULL_REVISION,
122
164
                             _mod_revision.ensure_null(branch.last_revision()))
123
 
        finally:
124
 
            branch.unlock()
125
165
 
126
166
    def start_server_inet(self, extra_options=()):
127
 
        """Start a bzr server subprocess using the --inet option.
 
167
        """Start a brz server subprocess using the --inet option.
128
168
 
129
169
        :param extra_options: extra options to give the server.
130
 
        :return: a tuple with the bzr process handle for passing to
 
170
        :return: a tuple with the brz process handle for passing to
131
171
            finish_bzr_subprocess, a client for the server, and a transport.
132
172
        """
133
173
        # Serve from the current directory
146
186
        return process, transport
147
187
 
148
188
    def start_server_port(self, extra_options=()):
149
 
        """Start a bzr server subprocess.
 
189
        """Start a brz server subprocess.
150
190
 
151
191
        :param extra_options: extra options to give the server.
152
 
        :return: a tuple with the bzr process handle for passing to
 
192
        :return: a tuple with the brz process handle for passing to
153
193
            finish_bzr_subprocess, and the base url for the server.
154
194
        """
155
195
        # Serve from the current directory
156
 
        args = ['serve', '--port', 'localhost:0']
 
196
        args = ['serve', '--listen', 'localhost', '--port', '0']
157
197
        args.extend(extra_options)
158
198
        process = self.start_bzr_subprocess(args, skip_if_plan_to_signal=True)
159
199
        port_line = process.stderr.readline()
160
 
        prefix = 'listening on port: '
 
200
        prefix = b'listening on port: '
161
201
        self.assertStartsWith(port_line, prefix)
162
202
        port = int(port_line[len(prefix):])
163
203
        url = 'bzr://localhost:%d/' % port
164
204
        self.permit_url(url)
165
205
        return process, url
166
 
    
 
206
 
167
207
    def test_bzr_serve_quiet(self):
168
208
        self.make_branch('.')
169
 
        args = ['--port', 'localhost:0', '--quiet']
 
209
        args = ['--listen', 'localhost', '--port', '0', '--quiet']
170
210
        out, err = self.run_bzr_serve_then_func(args, retcode=3)
171
211
        self.assertEqual('', out)
172
212
        self.assertEqual('', err)
173
213
 
174
214
    def test_bzr_serve_inet_readonly(self):
175
 
        """bzr server should provide a read only filesystem by default."""
 
215
        """brz server should provide a read only filesystem by default."""
176
216
        process, transport = self.start_server_inet()
177
217
        self.assertRaises(errors.TransportNotPossible, transport.mkdir, 'adir')
178
218
        self.assertInetServerShutsdownCleanly(process)
184
224
        process, transport = self.start_server_inet(['--allow-writes'])
185
225
 
186
226
        # We get a working branch, and can create a directory
187
 
        branch = BzrDir.open_from_transport(transport).open_branch()
 
227
        branch = ControlDir.open_from_transport(transport).open_branch()
188
228
        self.make_read_requests(branch)
189
229
        transport.mkdir('adir')
190
230
        self.assertInetServerShutsdownCleanly(process)
191
231
 
192
232
    def test_bzr_serve_port_readonly(self):
193
 
        """bzr server should provide a read only filesystem by default."""
 
233
        """brz server should provide a read only filesystem by default."""
194
234
        process, url = self.start_server_port()
195
 
        transport = get_transport(url)
196
 
        self.assertRaises(errors.TransportNotPossible, transport.mkdir, 'adir')
 
235
        t = transport.get_transport_from_url(url)
 
236
        self.assertRaises(errors.TransportNotPossible, t.mkdir, 'adir')
197
237
        self.assertServerFinishesCleanly(process)
198
238
 
199
239
    def test_bzr_serve_port_readwrite(self):
223
263
        # This is a smoke test that the server doesn't crash when run with
224
264
        # -Dhpss, and does drop some hpss logging to the file.
225
265
        self.make_branch('.')
226
 
        log_fname = os.getcwd() + '/server.log'
227
 
        self._captureVar('BZR_LOG', log_fname)
 
266
        log_fname = self.test_dir + '/server.log'
 
267
        self.overrideEnv('BRZ_LOG', log_fname)
228
268
        process, transport = self.start_server_inet(['-Dhpss'])
229
 
        branch = BzrDir.open_from_transport(transport).open_branch()
 
269
        branch = ControlDir.open_from_transport(transport).open_branch()
230
270
        self.make_read_requests(branch)
231
271
        self.assertInetServerShutsdownCleanly(process)
232
272
        f = open(log_fname, 'rb')
233
273
        content = f.read()
234
274
        f.close()
235
 
        self.assertContainsRe(content, r'hpss request: \[[0-9-]+\]')
 
275
        self.assertContainsRe(content, br'hpss request: \[[0-9-]+\]')
 
276
 
 
277
    def test_bzr_serve_supports_configurable_timeout(self):
 
278
        gs = config.GlobalStack()
 
279
        gs.set('serve.client_timeout', 0.2)
 
280
        # Save the config as the subprocess will use it
 
281
        gs.store.save()
 
282
        process, url = self.start_server_port()
 
283
        self.build_tree_contents([('a_file', b'contents\n')])
 
284
        # We can connect and issue a request
 
285
        t = transport.get_transport_from_url(url)
 
286
        self.assertEqual(b'contents\n', t.get_bytes('a_file'))
 
287
        # However, if we just wait for more content from the server, it will
 
288
        # eventually disconnect us.
 
289
        m = t.get_smart_medium()
 
290
        m.read_bytes(1)
 
291
        # Now, we wait for timeout to trigger
 
292
        err = process.stderr.readline()
 
293
        self.assertEqual(
 
294
            b'Connection Timeout: disconnecting client after 0.2 seconds\n',
 
295
            err)
 
296
        self.assertServerFinishesCleanly(process)
 
297
 
 
298
    def test_bzr_serve_supports_client_timeout(self):
 
299
        process, url = self.start_server_port(['--client-timeout=0.1'])
 
300
        self.build_tree_contents([('a_file', b'contents\n')])
 
301
        # We can connect and issue a request
 
302
        t = transport.get_transport_from_url(url)
 
303
        self.assertEqual(b'contents\n', t.get_bytes('a_file'))
 
304
        # However, if we just wait for more content from the server, it will
 
305
        # eventually disconnect us.
 
306
        # TODO: Use something like signal.alarm() so that if the server doesn't
 
307
        #       properly handle the timeout, we end up failing the test instead
 
308
        #       of hanging forever.
 
309
        m = t.get_smart_medium()
 
310
        m.read_bytes(1)
 
311
        # Now, we wait for timeout to trigger
 
312
        err = process.stderr.readline()
 
313
        self.assertEqual(
 
314
            b'Connection Timeout: disconnecting client after 0.1 seconds\n',
 
315
            err)
 
316
        self.assertServerFinishesCleanly(process)
 
317
 
 
318
    def test_bzr_serve_graceful_shutdown(self):
 
319
        big_contents = b'a' * 64 * 1024
 
320
        self.build_tree_contents([('bigfile', big_contents)])
 
321
        process, url = self.start_server_port(['--client-timeout=1.0'])
 
322
        t = transport.get_transport_from_url(url)
 
323
        m = t.get_smart_medium()
 
324
        c = client._SmartClient(m)
 
325
        # Start, but don't finish a response
 
326
        resp, response_handler = c.call_expecting_body(b'get', b'bigfile')
 
327
        self.assertEqual((b'ok',), resp)
 
328
        # Note: process.send_signal is a Python 2.6ism
 
329
        process.send_signal(signal.SIGHUP)
 
330
        # Wait for the server to notice the signal, and then read the actual
 
331
        # body of the response. That way we know that it is waiting for the
 
332
        # request to finish
 
333
        self.assertEqual(b'Requested to stop gracefully\n',
 
334
                         process.stderr.readline())
 
335
        self.assertIn(process.stderr.readline(),
 
336
                      (b'', b'Waiting for 1 client(s) to finish\n'))
 
337
        body = response_handler.read_body_bytes()
 
338
        if body != big_contents:
 
339
            self.fail('Failed to properly read the contents of "bigfile"')
 
340
        # Now that our request is finished, the medium should notice it has
 
341
        # been disconnected.
 
342
        self.assertEqual(b'', m.read_bytes(1))
 
343
        # And the server should be stopping
 
344
        self.assertEqual(0, process.wait())
236
345
 
237
346
 
238
347
class TestCmdServeChrooting(TestBzrServeBase):
239
348
 
240
349
    def test_serve_tcp(self):
241
 
        """'bzr serve' wraps the given --directory in a ChrootServer.
 
350
        """'brz serve' wraps the given --directory in a ChrootServer.
242
351
 
243
352
        So requests that search up through the parent directories (like
244
353
        find_repositoryV3) will give "not found" responses, rather than
247
356
        t = self.get_transport()
248
357
        t.mkdir('server-root')
249
358
        self.run_bzr_serve_then_func(
250
 
            ['--port', '127.0.0.1:0',
 
359
            ['--listen', '127.0.0.1', '--port', '0',
251
360
             '--directory', t.local_abspath('server-root'),
252
361
             '--allow-writes'],
253
362
            func=self.when_server_started)
254
363
        # The when_server_started method issued a find_repositoryV3 that should
255
364
        # fail with 'norepository' because there are no repositories inside the
256
365
        # --directory.
257
 
        self.assertEqual(('norepository',), self.client_resp)
 
366
        self.assertEqual((b'norepository',), self.client_resp)
258
367
 
259
368
    def when_server_started(self):
260
369
        # Connect to the TCP server and issue some requests and see what comes
267
376
        resp = smart_client.call('BzrDirFormat.initialize', 'foo/')
268
377
        try:
269
378
            resp = smart_client.call('BzrDir.find_repositoryV3', 'foo/')
270
 
        except errors.ErrorFromSmartServer, e:
 
379
        except errors.ErrorFromSmartServer as e:
271
380
            resp = e.error_tuple
272
381
        self.client_resp = resp
273
382
        client_medium.disconnect()
275
384
 
276
385
class TestUserdirExpansion(TestCaseWithMemoryTransport):
277
386
 
278
 
    def fake_expanduser(self, path):
 
387
    @staticmethod
 
388
    def fake_expanduser(path):
279
389
        """A simple, environment-independent, function for the duration of this
280
390
        test.
281
391
 
293
403
        bzr_server = BzrServerFactory(
294
404
            self.fake_expanduser, lambda t: base_path)
295
405
        mem_transport = self.get_transport()
296
 
        mem_transport.mkdir_multi(['home', 'home/user'])
297
 
        bzr_server.set_up(mem_transport, None, None, inet=True)
 
406
        mem_transport.mkdir('home')
 
407
        mem_transport.mkdir('home/user')
 
408
        bzr_server.set_up(mem_transport, None, None, inet=True, timeout=4.0)
298
409
        self.addCleanup(bzr_server.tear_down)
299
410
        return bzr_server
300
411
 
304
415
 
305
416
    def test_bzr_serve_does_not_expand_userdir_outside_base(self):
306
417
        bzr_server = self.make_test_server('/foo')
307
 
        self.assertFalse(bzr_server.smart_server.backing_transport.has('~user'))
 
418
        self.assertFalse(
 
419
            bzr_server.smart_server.backing_transport.has('~user'))
308
420
 
309
421
    def test_get_base_path(self):
310
422
        """cmd_serve will turn the --directory option into a LocalTransport
316
428
        base_url = urlutils.local_path_to_url(base_dir) + '/'
317
429
        # Define a fake 'protocol' to capture the transport that cmd_serve
318
430
        # passes to serve_bzr.
319
 
        def capture_transport(transport, host, port, inet):
 
431
 
 
432
        def capture_transport(transport, host, port, inet, timeout):
320
433
            self.bzr_serve_transport = transport
321
434
        cmd = builtins.cmd_serve()
322
435
        # Read-only
328
441
            base_dir, server_maker.get_base_path(self.bzr_serve_transport))
329
442
        # Read-write
330
443
        cmd.run(directory=base_dir, protocol=capture_transport,
331
 
            allow_writes=True)
 
444
                allow_writes=True)
332
445
        server_maker = BzrServerFactory()
333
446
        self.assertEqual(base_url, self.bzr_serve_transport.base)
334
447
        self.assertEqual(base_dir,
335
 
            server_maker.get_base_path(self.bzr_serve_transport))
336
 
 
 
448
                         server_maker.get_base_path(self.bzr_serve_transport))
 
449
        # Read-only, from a URL
 
450
        cmd.run(directory=base_url, protocol=capture_transport)
 
451
        server_maker = BzrServerFactory()
 
452
        self.assertEqual(
 
453
            'readonly+%s' % base_url, self.bzr_serve_transport.base)
 
454
        self.assertEqual(
 
455
            base_dir, server_maker.get_base_path(self.bzr_serve_transport))