/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: Martin
  • Date: 2017-06-10 01:57:00 UTC
  • mto: This revision was merged to the branch mainline in revision 6679.
  • Revision ID: gzlist@googlemail.com-20170610015700-o3xeuyaqry2obiay
Go back to native str for urls and many other py3 changes

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/blackbox/test_serve.py
 
1
# Copyright (C) 2006-2011 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
 
 
18
"""Tests of the brz serve command."""
 
19
 
 
20
import os
 
21
import signal
 
22
import sys
 
23
import thread
 
24
import threading
 
25
 
 
26
from ... import (
 
27
    builtins,
 
28
    config,
 
29
    errors,
 
30
    osutils,
 
31
    revision as _mod_revision,
 
32
    trace,
 
33
    transport,
 
34
    urlutils,
 
35
    )
 
36
from ...branch import Branch
 
37
from ...controldir import ControlDir
 
38
from ...smart import client, medium
 
39
from ...smart.server import (
 
40
    BzrServerFactory,
 
41
    SmartTCPServer,
 
42
    )
 
43
from .. import (
 
44
    TestCaseWithMemoryTransport,
 
45
    TestCaseWithTransport,
 
46
    )
 
47
from ...transport import remote
 
48
 
 
49
 
 
50
class TestBzrServeBase(TestCaseWithTransport):
 
51
 
 
52
    def run_bzr_serve_then_func(self, serve_args, retcode=0, func=None,
 
53
                                *func_args, **func_kwargs):
 
54
        """Run 'brz serve', and run the given func in a thread once the server
 
55
        has started.
 
56
 
 
57
        When 'func' terminates, the server will be terminated too.
 
58
 
 
59
        Returns stdout and stderr.
 
60
        """
 
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
            """
 
67
            try:
 
68
                # Run func if set
 
69
                self.tcp_server = tcp_server
 
70
                if func is not None:
 
71
                    try:
 
72
                        func(*func_args, **func_kwargs)
 
73
                    except Exception as e:
 
74
                        # Log errors to make some test failures a little less
 
75
                        # mysterious.
 
76
                        trace.mutter('func broke: %r', e)
 
77
            finally:
 
78
                # Then stop the server
 
79
                trace.mutter('interrupting...')
 
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
 
88
        SmartTCPServer.hooks.install_named_hook(
 
89
            'server_started_ex', on_server_start,
 
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)
 
95
        # start a TCP server
 
96
        try:
 
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())
 
102
        return out, err
 
103
 
 
104
 
 
105
class TestBzrServe(TestBzrServeBase):
 
106
 
 
107
    def setUp(self):
 
108
        super(TestBzrServe, self).setUp()
 
109
        self.disable_missing_extensions_warning()
 
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
 
 
135
    def assertInetServerShutsdownCleanly(self, process):
 
136
        """Shutdown the server process looking for errors."""
 
137
        # Shutdown the server: the server should shut down when it cannot read
 
138
        # from stdin anymore.
 
139
        process.stdin.close()
 
140
        # Hide stdin from the subprocess module, so it won't fail to close it.
 
141
        process.stdin = None
 
142
        result = self.finish_bzr_subprocess(process)
 
143
        self.assertEqual('', result[0])
 
144
        self.assertEqual('', result[1])
 
145
 
 
146
    def assertServerFinishesCleanly(self, process):
 
147
        """Shutdown the brz serve instance process looking for errors."""
 
148
        # Shutdown the server
 
149
        result = self.finish_bzr_subprocess(process, retcode=3,
 
150
                                            send_signal=signal.SIGINT)
 
151
        self.assertEqual('', result[0])
 
152
        self.assertEqual('brz: interrupted\n', result[1])
 
153
 
 
154
    def make_read_requests(self, branch):
 
155
        """Do some read only requests."""
 
156
        branch.lock_read()
 
157
        try:
 
158
            branch.repository.all_revision_ids()
 
159
            self.assertEqual(_mod_revision.NULL_REVISION,
 
160
                             _mod_revision.ensure_null(branch.last_revision()))
 
161
        finally:
 
162
            branch.unlock()
 
163
 
 
164
    def start_server_inet(self, extra_options=()):
 
165
        """Start a brz server subprocess using the --inet option.
 
166
 
 
167
        :param extra_options: extra options to give the server.
 
168
        :return: a tuple with the brz process handle for passing to
 
169
            finish_bzr_subprocess, a client for the server, and a transport.
 
170
        """
 
171
        # Serve from the current directory
 
172
        args = ['serve', '--inet']
 
173
        args.extend(extra_options)
 
174
        process = self.start_bzr_subprocess(args)
 
175
 
 
176
        # Connect to the server
 
177
        # We use this url because while this is no valid URL to connect to this
 
178
        # server instance, the transport needs a URL.
 
179
        url = 'bzr://localhost/'
 
180
        self.permit_url(url)
 
181
        client_medium = medium.SmartSimplePipesClientMedium(
 
182
            process.stdout, process.stdin, url)
 
183
        transport = remote.RemoteTransport(url, medium=client_medium)
 
184
        return process, transport
 
185
 
 
186
    def start_server_port(self, extra_options=()):
 
187
        """Start a brz server subprocess.
 
188
 
 
189
        :param extra_options: extra options to give the server.
 
190
        :return: a tuple with the brz process handle for passing to
 
191
            finish_bzr_subprocess, and the base url for the server.
 
192
        """
 
193
        # Serve from the current directory
 
194
        args = ['serve', '--listen', 'localhost', '--port', '0']
 
195
        args.extend(extra_options)
 
196
        process = self.start_bzr_subprocess(args, skip_if_plan_to_signal=True)
 
197
        port_line = process.stderr.readline()
 
198
        prefix = 'listening on port: '
 
199
        self.assertStartsWith(port_line, prefix)
 
200
        port = int(port_line[len(prefix):])
 
201
        url = 'bzr://localhost:%d/' % port
 
202
        self.permit_url(url)
 
203
        return process, url
 
204
 
 
205
    def test_bzr_serve_quiet(self):
 
206
        self.make_branch('.')
 
207
        args = ['--listen', 'localhost', '--port', '0', '--quiet']
 
208
        out, err = self.run_bzr_serve_then_func(args, retcode=3)
 
209
        self.assertEqual('', out)
 
210
        self.assertEqual('', err)
 
211
 
 
212
    def test_bzr_serve_inet_readonly(self):
 
213
        """brz server should provide a read only filesystem by default."""
 
214
        process, transport = self.start_server_inet()
 
215
        self.assertRaises(errors.TransportNotPossible, transport.mkdir, 'adir')
 
216
        self.assertInetServerShutsdownCleanly(process)
 
217
 
 
218
    def test_bzr_serve_inet_readwrite(self):
 
219
        # Make a branch
 
220
        self.make_branch('.')
 
221
 
 
222
        process, transport = self.start_server_inet(['--allow-writes'])
 
223
 
 
224
        # We get a working branch, and can create a directory
 
225
        branch = ControlDir.open_from_transport(transport).open_branch()
 
226
        self.make_read_requests(branch)
 
227
        transport.mkdir('adir')
 
228
        self.assertInetServerShutsdownCleanly(process)
 
229
 
 
230
    def test_bzr_serve_port_readonly(self):
 
231
        """brz server should provide a read only filesystem by default."""
 
232
        process, url = self.start_server_port()
 
233
        t = transport.get_transport_from_url(url)
 
234
        self.assertRaises(errors.TransportNotPossible, t.mkdir, 'adir')
 
235
        self.assertServerFinishesCleanly(process)
 
236
 
 
237
    def test_bzr_serve_port_readwrite(self):
 
238
        # Make a branch
 
239
        self.make_branch('.')
 
240
 
 
241
        process, url = self.start_server_port(['--allow-writes'])
 
242
 
 
243
        # Connect to the server
 
244
        branch = Branch.open(url)
 
245
        self.make_read_requests(branch)
 
246
        self.assertServerFinishesCleanly(process)
 
247
 
 
248
    def test_bzr_serve_supports_protocol(self):
 
249
        # Make a branch
 
250
        self.make_branch('.')
 
251
 
 
252
        process, url = self.start_server_port(['--allow-writes',
 
253
                                               '--protocol=bzr'])
 
254
 
 
255
        # Connect to the server
 
256
        branch = Branch.open(url)
 
257
        self.make_read_requests(branch)
 
258
        self.assertServerFinishesCleanly(process)
 
259
 
 
260
    def test_bzr_serve_dhpss(self):
 
261
        # This is a smoke test that the server doesn't crash when run with
 
262
        # -Dhpss, and does drop some hpss logging to the file.
 
263
        self.make_branch('.')
 
264
        log_fname = self.test_dir + '/server.log'
 
265
        self.overrideEnv('BRZ_LOG', log_fname)
 
266
        process, transport = self.start_server_inet(['-Dhpss'])
 
267
        branch = ControlDir.open_from_transport(transport).open_branch()
 
268
        self.make_read_requests(branch)
 
269
        self.assertInetServerShutsdownCleanly(process)
 
270
        f = open(log_fname, 'rb')
 
271
        content = f.read()
 
272
        f.close()
 
273
        self.assertContainsRe(content, r'hpss request: \[[0-9-]+\]')
 
274
 
 
275
    def test_bzr_serve_supports_configurable_timeout(self):
 
276
        gs = config.GlobalStack()
 
277
        gs.set('serve.client_timeout', 0.2)
 
278
        # Save the config as the subprocess will use it
 
279
        gs.store.save()
 
280
        process, url = self.start_server_port()
 
281
        self.build_tree_contents([('a_file', 'contents\n')])
 
282
        # We can connect and issue a request
 
283
        t = transport.get_transport_from_url(url)
 
284
        self.assertEqual('contents\n', t.get_bytes('a_file'))
 
285
        # However, if we just wait for more content from the server, it will
 
286
        # eventually disconnect us.
 
287
        m = t.get_smart_medium()
 
288
        m.read_bytes(1)
 
289
        # Now, we wait for timeout to trigger
 
290
        err = process.stderr.readline()
 
291
        self.assertEqual(
 
292
            'Connection Timeout: disconnecting client after 0.2 seconds\n',
 
293
            err)
 
294
        self.assertServerFinishesCleanly(process)
 
295
 
 
296
    def test_bzr_serve_supports_client_timeout(self):
 
297
        process, url = self.start_server_port(['--client-timeout=0.1'])
 
298
        self.build_tree_contents([('a_file', 'contents\n')])
 
299
        # We can connect and issue a request
 
300
        t = transport.get_transport_from_url(url)
 
301
        self.assertEqual('contents\n', t.get_bytes('a_file'))
 
302
        # However, if we just wait for more content from the server, it will
 
303
        # eventually disconnect us.
 
304
        # TODO: Use something like signal.alarm() so that if the server doesn't
 
305
        #       properly handle the timeout, we end up failing the test instead
 
306
        #       of hanging forever.
 
307
        m = t.get_smart_medium()
 
308
        m.read_bytes(1)
 
309
        # Now, we wait for timeout to trigger
 
310
        err = process.stderr.readline()
 
311
        self.assertEqual(
 
312
            'Connection Timeout: disconnecting client after 0.1 seconds\n',
 
313
            err)
 
314
        self.assertServerFinishesCleanly(process)
 
315
 
 
316
    def test_bzr_serve_graceful_shutdown(self):
 
317
        big_contents = 'a'*64*1024
 
318
        self.build_tree_contents([('bigfile', big_contents)])
 
319
        process, url = self.start_server_port(['--client-timeout=1.0'])
 
320
        t = transport.get_transport_from_url(url)
 
321
        m = t.get_smart_medium()
 
322
        c = client._SmartClient(m)
 
323
        # Start, but don't finish a response
 
324
        resp, response_handler = c.call_expecting_body('get', 'bigfile')
 
325
        self.assertEqual(('ok',), resp)
 
326
        # Note: process.send_signal is a Python 2.6ism
 
327
        process.send_signal(signal.SIGHUP)
 
328
        # Wait for the server to notice the signal, and then read the actual
 
329
        # body of the response. That way we know that it is waiting for the
 
330
        # request to finish
 
331
        self.assertEqual('Requested to stop gracefully\n',
 
332
                         process.stderr.readline())
 
333
        self.assertEqual('Waiting for 1 client(s) to finish\n',
 
334
                         process.stderr.readline())
 
335
        body = response_handler.read_body_bytes()
 
336
        if body != big_contents:
 
337
            self.fail('Failed to properly read the contents of "bigfile"')
 
338
        # Now that our request is finished, the medium should notice it has
 
339
        # been disconnected.
 
340
        self.assertEqual('', m.read_bytes(1))
 
341
        # And the server should be stopping
 
342
        self.assertEqual(0, process.wait())
 
343
 
 
344
 
 
345
class TestCmdServeChrooting(TestBzrServeBase):
 
346
 
 
347
    def test_serve_tcp(self):
 
348
        """'brz serve' wraps the given --directory in a ChrootServer.
 
349
 
 
350
        So requests that search up through the parent directories (like
 
351
        find_repositoryV3) will give "not found" responses, rather than
 
352
        InvalidURLJoin or jail break errors.
 
353
        """
 
354
        t = self.get_transport()
 
355
        t.mkdir('server-root')
 
356
        self.run_bzr_serve_then_func(
 
357
            ['--listen', '127.0.0.1', '--port', '0',
 
358
             '--directory', t.local_abspath('server-root'),
 
359
             '--allow-writes'],
 
360
            func=self.when_server_started)
 
361
        # The when_server_started method issued a find_repositoryV3 that should
 
362
        # fail with 'norepository' because there are no repositories inside the
 
363
        # --directory.
 
364
        self.assertEqual(('norepository',), self.client_resp)
 
365
 
 
366
    def when_server_started(self):
 
367
        # Connect to the TCP server and issue some requests and see what comes
 
368
        # back.
 
369
        client_medium = medium.SmartTCPClientMedium(
 
370
            '127.0.0.1', self.tcp_server.port,
 
371
            'bzr://localhost:%d/' % (self.tcp_server.port,))
 
372
        smart_client = client._SmartClient(client_medium)
 
373
        resp = smart_client.call('mkdir', 'foo', '')
 
374
        resp = smart_client.call('BzrDirFormat.initialize', 'foo/')
 
375
        try:
 
376
            resp = smart_client.call('BzrDir.find_repositoryV3', 'foo/')
 
377
        except errors.ErrorFromSmartServer as e:
 
378
            resp = e.error_tuple
 
379
        self.client_resp = resp
 
380
        client_medium.disconnect()
 
381
 
 
382
 
 
383
class TestUserdirExpansion(TestCaseWithMemoryTransport):
 
384
 
 
385
    @staticmethod
 
386
    def fake_expanduser(path):
 
387
        """A simple, environment-independent, function for the duration of this
 
388
        test.
 
389
 
 
390
        Paths starting with a path segment of '~user' will expand to start with
 
391
        '/home/user/'.  Every other path will be unchanged.
 
392
        """
 
393
        if path.split('/', 1)[0] == '~user':
 
394
            return '/home/user' + path[len('~user'):]
 
395
        return path
 
396
 
 
397
    def make_test_server(self, base_path='/'):
 
398
        """Make and start a BzrServerFactory, backed by a memory transport, and
 
399
        creat '/home/user' in that transport.
 
400
        """
 
401
        bzr_server = BzrServerFactory(
 
402
            self.fake_expanduser, lambda t: base_path)
 
403
        mem_transport = self.get_transport()
 
404
        mem_transport.mkdir_multi(['home', 'home/user'])
 
405
        bzr_server.set_up(mem_transport, None, None, inet=True, timeout=4.0)
 
406
        self.addCleanup(bzr_server.tear_down)
 
407
        return bzr_server
 
408
 
 
409
    def test_bzr_serve_expands_userdir(self):
 
410
        bzr_server = self.make_test_server()
 
411
        self.assertTrue(bzr_server.smart_server.backing_transport.has('~user'))
 
412
 
 
413
    def test_bzr_serve_does_not_expand_userdir_outside_base(self):
 
414
        bzr_server = self.make_test_server('/foo')
 
415
        self.assertFalse(bzr_server.smart_server.backing_transport.has('~user'))
 
416
 
 
417
    def test_get_base_path(self):
 
418
        """cmd_serve will turn the --directory option into a LocalTransport
 
419
        (optionally decorated with 'readonly+').  BzrServerFactory can
 
420
        determine the original --directory from that transport.
 
421
        """
 
422
        # URLs always include the trailing slash, and get_base_path returns it
 
423
        base_dir = osutils.abspath('/a/b/c') + '/'
 
424
        base_url = urlutils.local_path_to_url(base_dir) + '/'
 
425
        # Define a fake 'protocol' to capture the transport that cmd_serve
 
426
        # passes to serve_bzr.
 
427
        def capture_transport(transport, host, port, inet, timeout):
 
428
            self.bzr_serve_transport = transport
 
429
        cmd = builtins.cmd_serve()
 
430
        # Read-only
 
431
        cmd.run(directory=base_dir, protocol=capture_transport)
 
432
        server_maker = BzrServerFactory()
 
433
        self.assertEqual(
 
434
            'readonly+%s' % base_url, self.bzr_serve_transport.base)
 
435
        self.assertEqual(
 
436
            base_dir, server_maker.get_base_path(self.bzr_serve_transport))
 
437
        # Read-write
 
438
        cmd.run(directory=base_dir, protocol=capture_transport,
 
439
            allow_writes=True)
 
440
        server_maker = BzrServerFactory()
 
441
        self.assertEqual(base_url, self.bzr_serve_transport.base)
 
442
        self.assertEqual(base_dir,
 
443
            server_maker.get_base_path(self.bzr_serve_transport))
 
444
        # Read-only, from a URL
 
445
        cmd.run(directory=base_url, protocol=capture_transport)
 
446
        server_maker = BzrServerFactory()
 
447
        self.assertEqual(
 
448
            'readonly+%s' % base_url, self.bzr_serve_transport.base)
 
449
        self.assertEqual(
 
450
            base_dir, server_maker.get_base_path(self.bzr_serve_transport))