/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-07-08 14:45:27 UTC
  • mto: This revision was merged to the branch mainline in revision 7036.
  • Revision ID: jelmer@jelmer.uk-20180708144527-codhlvdcdg9y0nji
Fix a bunch of merge tests.

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
        def on_server_start(backing_urls, tcp_server):
 
88
            t = threading.Thread(
 
89
                target=on_server_start_thread, args=(tcp_server,))
 
90
            t.start()
 
91
        # install hook
80
92
        SmartTCPServer.hooks.install_named_hook(
81
93
            'server_started_ex', on_server_start,
82
94
            'run_bzr_serve_then_func hook')
 
95
        # It seems interrupt_main() will not raise KeyboardInterrupt
 
96
        # until after socket.accept returns. So we set the timeout low to make
 
97
        # the test faster.
 
98
        self.overrideAttr(SmartTCPServer, '_ACCEPT_TIMEOUT', 0.1)
83
99
        # start a TCP server
84
100
        try:
85
 
            out, err = self.run_bzr(['serve'] + list(serve_args))
86
 
        except KeyboardInterrupt, e:
87
 
            out, err = e.args
 
101
            out, err = self.run_bzr(['serve'] + list(serve_args),
 
102
                                    retcode=retcode)
 
103
        except KeyboardInterrupt as e:
 
104
            return (self._last_cmd_stdout.getvalue(),
 
105
                self._last_cmd_stderr.getvalue())
88
106
        return out, err
89
107
 
90
108
 
94
112
        super(TestBzrServe, self).setUp()
95
113
        self.disable_missing_extensions_warning()
96
114
 
 
115
    def test_server_exception_with_hook(self):
 
116
        """Catch exception from the server in the server_exception hook.
 
117
 
 
118
        We use ``run_bzr_serve_then_func`` without a ``func`` so the server
 
119
        will receive a KeyboardInterrupt exception we want to catch.
 
120
        """
 
121
        def hook(exception):
 
122
            if exception[0] is KeyboardInterrupt:
 
123
                sys.stderr.write(b'catching KeyboardInterrupt\n')
 
124
                return True
 
125
            else:
 
126
                return False
 
127
        SmartTCPServer.hooks.install_named_hook(
 
128
            'server_exception', hook,
 
129
            'test_server_except_hook hook')
 
130
        args = ['--listen', 'localhost', '--port', '0', '--quiet']
 
131
        out, err = self.run_bzr_serve_then_func(args, retcode=0)
 
132
        self.assertEqual(b'catching KeyboardInterrupt\n', err)
 
133
 
 
134
    def test_server_exception_no_hook(self):
 
135
        """test exception without hook returns error"""
 
136
        args = []
 
137
        out, err = self.run_bzr_serve_then_func(args, retcode=3)
 
138
 
97
139
    def assertInetServerShutsdownCleanly(self, process):
98
140
        """Shutdown the server process looking for errors."""
99
141
        # Shutdown the server: the server should shut down when it cannot read
102
144
        # Hide stdin from the subprocess module, so it won't fail to close it.
103
145
        process.stdin = None
104
146
        result = self.finish_bzr_subprocess(process)
105
 
        self.assertEqual('', result[0])
106
 
        self.assertEqual('', result[1])
 
147
        self.assertEqual(b'', result[0])
 
148
        self.assertEqual(b'', result[1])
107
149
 
108
150
    def assertServerFinishesCleanly(self, process):
109
 
        """Shutdown the bzr serve instance process looking for errors."""
 
151
        """Shutdown the brz serve instance process looking for errors."""
110
152
        # Shutdown the server
111
153
        result = self.finish_bzr_subprocess(process, retcode=3,
112
154
                                            send_signal=signal.SIGINT)
113
 
        self.assertEqual('', result[0])
114
 
        self.assertEqual('bzr: interrupted\n', result[1])
 
155
        self.assertEqual(b'', result[0])
 
156
        self.assertEqual(b'brz: interrupted\n', result[1])
115
157
 
116
158
    def make_read_requests(self, branch):
117
159
        """Do some read only requests."""
118
 
        branch.lock_read()
119
 
        try:
 
160
        with branch.lock_read():
120
161
            branch.repository.all_revision_ids()
121
162
            self.assertEqual(_mod_revision.NULL_REVISION,
122
163
                             _mod_revision.ensure_null(branch.last_revision()))
123
 
        finally:
124
 
            branch.unlock()
125
164
 
126
165
    def start_server_inet(self, extra_options=()):
127
 
        """Start a bzr server subprocess using the --inet option.
 
166
        """Start a brz server subprocess using the --inet option.
128
167
 
129
168
        :param extra_options: extra options to give the server.
130
 
        :return: a tuple with the bzr process handle for passing to
 
169
        :return: a tuple with the brz process handle for passing to
131
170
            finish_bzr_subprocess, a client for the server, and a transport.
132
171
        """
133
172
        # Serve from the current directory
146
185
        return process, transport
147
186
 
148
187
    def start_server_port(self, extra_options=()):
149
 
        """Start a bzr server subprocess.
 
188
        """Start a brz server subprocess.
150
189
 
151
190
        :param extra_options: extra options to give the server.
152
 
        :return: a tuple with the bzr process handle for passing to
 
191
        :return: a tuple with the brz process handle for passing to
153
192
            finish_bzr_subprocess, and the base url for the server.
154
193
        """
155
194
        # Serve from the current directory
156
 
        args = ['serve', '--port', 'localhost:0']
 
195
        args = ['serve', '--listen', 'localhost', '--port', '0']
157
196
        args.extend(extra_options)
158
197
        process = self.start_bzr_subprocess(args, skip_if_plan_to_signal=True)
159
198
        port_line = process.stderr.readline()
160
 
        prefix = 'listening on port: '
 
199
        prefix = b'listening on port: '
161
200
        self.assertStartsWith(port_line, prefix)
162
201
        port = int(port_line[len(prefix):])
163
202
        url = 'bzr://localhost:%d/' % port
164
203
        self.permit_url(url)
165
204
        return process, url
166
 
    
 
205
 
167
206
    def test_bzr_serve_quiet(self):
168
207
        self.make_branch('.')
169
 
        args = ['--port', 'localhost:0', '--quiet']
 
208
        args = ['--listen', 'localhost', '--port', '0', '--quiet']
170
209
        out, err = self.run_bzr_serve_then_func(args, retcode=3)
171
 
        self.assertEqual('', out)
172
 
        self.assertEqual('', err)
 
210
        self.assertEqual(b'', out)
 
211
        self.assertEqual(b'', err)
173
212
 
174
213
    def test_bzr_serve_inet_readonly(self):
175
 
        """bzr server should provide a read only filesystem by default."""
 
214
        """brz server should provide a read only filesystem by default."""
176
215
        process, transport = self.start_server_inet()
177
216
        self.assertRaises(errors.TransportNotPossible, transport.mkdir, 'adir')
178
217
        self.assertInetServerShutsdownCleanly(process)
184
223
        process, transport = self.start_server_inet(['--allow-writes'])
185
224
 
186
225
        # We get a working branch, and can create a directory
187
 
        branch = BzrDir.open_from_transport(transport).open_branch()
 
226
        branch = ControlDir.open_from_transport(transport).open_branch()
188
227
        self.make_read_requests(branch)
189
228
        transport.mkdir('adir')
190
229
        self.assertInetServerShutsdownCleanly(process)
191
230
 
192
231
    def test_bzr_serve_port_readonly(self):
193
 
        """bzr server should provide a read only filesystem by default."""
 
232
        """brz server should provide a read only filesystem by default."""
194
233
        process, url = self.start_server_port()
195
 
        transport = get_transport(url)
196
 
        self.assertRaises(errors.TransportNotPossible, transport.mkdir, 'adir')
 
234
        t = transport.get_transport_from_url(url)
 
235
        self.assertRaises(errors.TransportNotPossible, t.mkdir, 'adir')
197
236
        self.assertServerFinishesCleanly(process)
198
237
 
199
238
    def test_bzr_serve_port_readwrite(self):
223
262
        # This is a smoke test that the server doesn't crash when run with
224
263
        # -Dhpss, and does drop some hpss logging to the file.
225
264
        self.make_branch('.')
226
 
        log_fname = os.getcwd() + '/server.log'
227
 
        self._captureVar('BZR_LOG', log_fname)
 
265
        log_fname = self.test_dir + '/server.log'
 
266
        self.overrideEnv('BRZ_LOG', log_fname)
228
267
        process, transport = self.start_server_inet(['-Dhpss'])
229
 
        branch = BzrDir.open_from_transport(transport).open_branch()
 
268
        branch = ControlDir.open_from_transport(transport).open_branch()
230
269
        self.make_read_requests(branch)
231
270
        self.assertInetServerShutsdownCleanly(process)
232
271
        f = open(log_fname, 'rb')
233
272
        content = f.read()
234
273
        f.close()
235
 
        self.assertContainsRe(content, r'hpss request: \[[0-9-]+\]')
 
274
        self.assertContainsRe(content, br'hpss request: \[[0-9-]+\]')
 
275
 
 
276
    def test_bzr_serve_supports_configurable_timeout(self):
 
277
        gs = config.GlobalStack()
 
278
        gs.set('serve.client_timeout', 0.2)
 
279
        # Save the config as the subprocess will use it
 
280
        gs.store.save()
 
281
        process, url = self.start_server_port()
 
282
        self.build_tree_contents([('a_file', b'contents\n')])
 
283
        # We can connect and issue a request
 
284
        t = transport.get_transport_from_url(url)
 
285
        self.assertEqual(b'contents\n', t.get_bytes('a_file'))
 
286
        # However, if we just wait for more content from the server, it will
 
287
        # eventually disconnect us.
 
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
            b'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', b'contents\n')])
 
300
        # We can connect and issue a request
 
301
        t = transport.get_transport_from_url(url)
 
302
        self.assertEqual(b'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
            b'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 = b'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((b'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(b'Requested to stop gracefully\n',
 
333
                         process.stderr.readline())
 
334
        self.assertEqual(b'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(b'', m.read_bytes(1))
 
342
        # And the server should be stopping
 
343
        self.assertEqual(0, process.wait())
236
344
 
237
345
 
238
346
class TestCmdServeChrooting(TestBzrServeBase):
239
347
 
240
348
    def test_serve_tcp(self):
241
 
        """'bzr serve' wraps the given --directory in a ChrootServer.
 
349
        """'brz serve' wraps the given --directory in a ChrootServer.
242
350
 
243
351
        So requests that search up through the parent directories (like
244
352
        find_repositoryV3) will give "not found" responses, rather than
247
355
        t = self.get_transport()
248
356
        t.mkdir('server-root')
249
357
        self.run_bzr_serve_then_func(
250
 
            ['--port', '127.0.0.1:0',
 
358
            ['--listen', '127.0.0.1', '--port', '0',
251
359
             '--directory', t.local_abspath('server-root'),
252
360
             '--allow-writes'],
253
361
            func=self.when_server_started)
254
362
        # The when_server_started method issued a find_repositoryV3 that should
255
363
        # fail with 'norepository' because there are no repositories inside the
256
364
        # --directory.
257
 
        self.assertEqual(('norepository',), self.client_resp)
 
365
        self.assertEqual((b'norepository',), self.client_resp)
258
366
 
259
367
    def when_server_started(self):
260
368
        # Connect to the TCP server and issue some requests and see what comes
267
375
        resp = smart_client.call('BzrDirFormat.initialize', 'foo/')
268
376
        try:
269
377
            resp = smart_client.call('BzrDir.find_repositoryV3', 'foo/')
270
 
        except errors.ErrorFromSmartServer, e:
 
378
        except errors.ErrorFromSmartServer as e:
271
379
            resp = e.error_tuple
272
380
        self.client_resp = resp
273
381
        client_medium.disconnect()
275
383
 
276
384
class TestUserdirExpansion(TestCaseWithMemoryTransport):
277
385
 
278
 
    def fake_expanduser(self, path):
 
386
    @staticmethod
 
387
    def fake_expanduser(path):
279
388
        """A simple, environment-independent, function for the duration of this
280
389
        test.
281
390
 
293
402
        bzr_server = BzrServerFactory(
294
403
            self.fake_expanduser, lambda t: base_path)
295
404
        mem_transport = self.get_transport()
296
 
        mem_transport.mkdir_multi(['home', 'home/user'])
297
 
        bzr_server.set_up(mem_transport, None, None, inet=True)
 
405
        mem_transport.mkdir('home')
 
406
        mem_transport.mkdir('home/user')
 
407
        bzr_server.set_up(mem_transport, None, None, inet=True, timeout=4.0)
298
408
        self.addCleanup(bzr_server.tear_down)
299
409
        return bzr_server
300
410
 
316
426
        base_url = urlutils.local_path_to_url(base_dir) + '/'
317
427
        # Define a fake 'protocol' to capture the transport that cmd_serve
318
428
        # passes to serve_bzr.
319
 
        def capture_transport(transport, host, port, inet):
 
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
333
443
        self.assertEqual(base_url, self.bzr_serve_transport.base)
334
444
        self.assertEqual(base_dir,
335
445
            server_maker.get_base_path(self.bzr_serve_transport))
336
 
 
 
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))