← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

(vila) Empty arguments in EDITOR are now properly preserved. (Vincent
 Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_serve.py
1
 
# Copyright (C) 2006 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
18
18
"""Tests of the bzr serve command."""
19
19
 
20
20
import os
21
21
import signal
22
 
import subprocess
23
22
import sys
 
23
import thread
24
24
import threading
25
25
 
26
26
from bzrlib import (
 
27
    builtins,
 
28
    config,
27
29
    errors,
28
30
    osutils,
29
31
    revision as _mod_revision,
 
32
    trace,
 
33
    transport,
 
34
    urlutils,
30
35
    )
31
36
from bzrlib.branch import Branch
32
 
from bzrlib.bzrdir import BzrDir
33
 
from bzrlib.errors import ParamikoNotPresent
34
 
from bzrlib.smart import medium
35
 
from bzrlib.tests import TestCaseWithTransport, TestSkipped
36
 
from bzrlib.transport import get_transport, remote
37
 
 
38
 
 
39
 
class TestBzrServe(TestCaseWithTransport):
 
37
from bzrlib.controldir import ControlDir
 
38
from bzrlib.smart import client, medium
 
39
from bzrlib.smart.server import (
 
40
    BzrServerFactory,
 
41
    SmartTCPServer,
 
42
    )
 
43
from bzrlib.tests import (
 
44
    TestCaseWithMemoryTransport,
 
45
    TestCaseWithTransport,
 
46
    )
 
47
from bzrlib.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 'bzr 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, 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, e:
 
100
            out, err = e.args
 
101
        return out, err
 
102
 
 
103
 
 
104
class TestBzrServe(TestBzrServeBase):
 
105
 
 
106
    def setUp(self):
 
107
        super(TestBzrServe, self).setUp()
 
108
        self.disable_missing_extensions_warning()
 
109
 
 
110
    def test_server_exception_with_hook(self):
 
111
        """Catch exception from the server in the server_exception hook.
 
112
 
 
113
        We use ``run_bzr_serve_then_func`` without a ``func`` so the server
 
114
        will receive a KeyboardInterrupt exception we want to catch.
 
115
        """
 
116
        def hook(exception):
 
117
            if exception[0] is KeyboardInterrupt:
 
118
                sys.stderr.write('catching KeyboardInterrupt\n')
 
119
                return True
 
120
            else:
 
121
                return False
 
122
        SmartTCPServer.hooks.install_named_hook(
 
123
            'server_exception', hook,
 
124
            'test_server_except_hook hook')
 
125
        args = ['--listen', 'localhost', '--port', '0', '--quiet']
 
126
        out, err = self.run_bzr_serve_then_func(args, retcode=0)
 
127
        self.assertEqual('catching KeyboardInterrupt\n', err)
 
128
 
 
129
    def test_server_exception_no_hook(self):
 
130
        """test exception without hook returns error"""
 
131
        args = []
 
132
        out, err = self.run_bzr_serve_then_func(args, retcode=3)
40
133
 
41
134
    def assertInetServerShutsdownCleanly(self, process):
42
135
        """Shutdown the server process looking for errors."""
48
141
        result = self.finish_bzr_subprocess(process)
49
142
        self.assertEqual('', result[0])
50
143
        self.assertEqual('', result[1])
51
 
    
 
144
 
52
145
    def assertServerFinishesCleanly(self, process):
53
146
        """Shutdown the bzr serve instance process looking for errors."""
54
147
        # Shutdown the server
75
168
            finish_bzr_subprocess, a client for the server, and a transport.
76
169
        """
77
170
        # Serve from the current directory
78
 
        process = self.start_bzr_subprocess(['serve', '--inet'])
 
171
        args = ['serve', '--inet']
 
172
        args.extend(extra_options)
 
173
        process = self.start_bzr_subprocess(args)
79
174
 
80
175
        # Connect to the server
81
176
        # We use this url because while this is no valid URL to connect to this
82
177
        # server instance, the transport needs a URL.
83
178
        url = 'bzr://localhost/'
 
179
        self.permit_url(url)
84
180
        client_medium = medium.SmartSimplePipesClientMedium(
85
181
            process.stdout, process.stdin, url)
86
182
        transport = remote.RemoteTransport(url, medium=client_medium)
94
190
            finish_bzr_subprocess, and the base url for the server.
95
191
        """
96
192
        # Serve from the current directory
97
 
        args = ['serve', '--port', 'localhost:0']
 
193
        args = ['serve', '--listen', 'localhost', '--port', '0']
98
194
        args.extend(extra_options)
99
195
        process = self.start_bzr_subprocess(args, skip_if_plan_to_signal=True)
100
 
        port_line = process.stdout.readline()
 
196
        port_line = process.stderr.readline()
101
197
        prefix = 'listening on port: '
102
198
        self.assertStartsWith(port_line, prefix)
103
199
        port = int(port_line[len(prefix):])
104
 
        return process,'bzr://localhost:%d/' % port
 
200
        url = 'bzr://localhost:%d/' % port
 
201
        self.permit_url(url)
 
202
        return process, url
 
203
 
 
204
    def test_bzr_serve_quiet(self):
 
205
        self.make_branch('.')
 
206
        args = ['--listen', 'localhost', '--port', '0', '--quiet']
 
207
        out, err = self.run_bzr_serve_then_func(args, retcode=3)
 
208
        self.assertEqual('', out)
 
209
        self.assertEqual('', err)
105
210
 
106
211
    def test_bzr_serve_inet_readonly(self):
107
212
        """bzr server should provide a read only filesystem by default."""
115
220
 
116
221
        process, transport = self.start_server_inet(['--allow-writes'])
117
222
 
118
 
        # We get a working branch
119
 
        branch = BzrDir.open_from_transport(transport).open_branch()
 
223
        # We get a working branch, and can create a directory
 
224
        branch = ControlDir.open_from_transport(transport).open_branch()
120
225
        self.make_read_requests(branch)
 
226
        transport.mkdir('adir')
121
227
        self.assertInetServerShutsdownCleanly(process)
122
228
 
123
229
    def test_bzr_serve_port_readonly(self):
124
230
        """bzr server should provide a read only filesystem by default."""
125
231
        process, url = self.start_server_port()
126
 
        transport = get_transport(url)
127
 
        self.assertRaises(errors.TransportNotPossible, transport.mkdir, 'adir')
 
232
        t = transport.get_transport_from_url(url)
 
233
        self.assertRaises(errors.TransportNotPossible, t.mkdir, 'adir')
128
234
        self.assertServerFinishesCleanly(process)
129
235
 
130
236
    def test_bzr_serve_port_readwrite(self):
138
244
        self.make_read_requests(branch)
139
245
        self.assertServerFinishesCleanly(process)
140
246
 
141
 
    def test_bzr_connect_to_bzr_ssh(self):
142
 
        """User acceptance that get_transport of a bzr+ssh:// behaves correctly.
143
 
 
144
 
        bzr+ssh:// should cause bzr to run a remote bzr smart server over SSH.
145
 
        """
146
 
        try:
147
 
            from bzrlib.transport.sftp import SFTPServer
148
 
        except ParamikoNotPresent:
149
 
            raise TestSkipped('Paramiko not installed')
150
 
        from bzrlib.tests.stub_sftp import StubServer
151
 
        
 
247
    def test_bzr_serve_supports_protocol(self):
152
248
        # Make a branch
153
 
        self.make_branch('a_branch')
154
 
 
155
 
        # Start an SSH server
156
 
        self.command_executed = []
157
 
        # XXX: This is horrible -- we define a really dumb SSH server that
158
 
        # executes commands, and manage the hooking up of stdin/out/err to the
159
 
        # SSH channel ourselves.  Surely this has already been implemented
160
 
        # elsewhere?
161
 
        class StubSSHServer(StubServer):
162
 
 
163
 
            test = self
164
 
 
165
 
            def check_channel_exec_request(self, channel, command):
166
 
                self.test.command_executed.append(command)
167
 
                proc = subprocess.Popen(
168
 
                    command, shell=True, stdin=subprocess.PIPE,
169
 
                    stdout=subprocess.PIPE, stderr=subprocess.PIPE)
170
 
                
171
 
                # XXX: horribly inefficient, not to mention ugly.
172
 
                # Start a thread for each of stdin/out/err, and relay bytes from
173
 
                # the subprocess to channel and vice versa.
174
 
                def ferry_bytes(read, write, close):
175
 
                    while True:
176
 
                        bytes = read(1)
177
 
                        if bytes == '':
178
 
                            close()
179
 
                            break
180
 
                        write(bytes)
181
 
 
182
 
                file_functions = [
183
 
                    (channel.recv, proc.stdin.write, proc.stdin.close),
184
 
                    (proc.stdout.read, channel.sendall, channel.close),
185
 
                    (proc.stderr.read, channel.sendall_stderr, channel.close)]
186
 
                for read, write, close in file_functions:
187
 
                    t = threading.Thread(
188
 
                        target=ferry_bytes, args=(read, write, close))
189
 
                    t.start()
190
 
 
191
 
                return True
192
 
 
193
 
        ssh_server = SFTPServer(StubSSHServer)
194
 
        # XXX: We *don't* want to override the default SSH vendor, so we set
195
 
        # _vendor to what _get_ssh_vendor returns.
196
 
        ssh_server.setUp()
197
 
        self.addCleanup(ssh_server.tearDown)
198
 
        port = ssh_server._listener.port
199
 
 
200
 
        # Access the branch via a bzr+ssh URL.  The BZR_REMOTE_PATH environment
201
 
        # variable is used to tell bzr what command to run on the remote end.
202
 
        path_to_branch = osutils.abspath('a_branch')
203
 
        
204
 
        orig_bzr_remote_path = os.environ.get('BZR_REMOTE_PATH')
205
 
        bzr_remote_path = self.get_bzr_path()
206
 
        if sys.platform == 'win32':
207
 
            bzr_remote_path = sys.executable + ' ' + self.get_bzr_path()
208
 
        os.environ['BZR_REMOTE_PATH'] = bzr_remote_path
 
249
        self.make_branch('.')
 
250
 
 
251
        process, url = self.start_server_port(['--allow-writes',
 
252
                                               '--protocol=bzr'])
 
253
 
 
254
        # Connect to the server
 
255
        branch = Branch.open(url)
 
256
        self.make_read_requests(branch)
 
257
        self.assertServerFinishesCleanly(process)
 
258
 
 
259
    def test_bzr_serve_dhpss(self):
 
260
        # This is a smoke test that the server doesn't crash when run with
 
261
        # -Dhpss, and does drop some hpss logging to the file.
 
262
        self.make_branch('.')
 
263
        log_fname = os.getcwd() + '/server.log'
 
264
        self.overrideEnv('BZR_LOG', log_fname)
 
265
        process, transport = self.start_server_inet(['-Dhpss'])
 
266
        branch = ControlDir.open_from_transport(transport).open_branch()
 
267
        self.make_read_requests(branch)
 
268
        self.assertInetServerShutsdownCleanly(process)
 
269
        f = open(log_fname, 'rb')
 
270
        content = f.read()
 
271
        f.close()
 
272
        self.assertContainsRe(content, r'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', 'contents\n')])
 
281
        # We can connect and issue a request
 
282
        t = transport.get_transport_from_url(url)
 
283
        self.assertEqual('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
            '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', 'contents\n')])
 
298
        # We can connect and issue a request
 
299
        t = transport.get_transport_from_url(url)
 
300
        self.assertEqual('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
            '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 = '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('get', 'bigfile')
 
324
        self.assertEqual(('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('Requested to stop gracefully\n',
 
331
                         process.stderr.readline())
 
332
        self.assertEqual('Waiting for 1 client(s) to finish\n',
 
333
                         process.stderr.readline())
 
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('', m.read_bytes(1))
 
340
        # And the server should be stopping
 
341
        self.assertEqual(0, process.wait())
 
342
 
 
343
 
 
344
class TestCmdServeChrooting(TestBzrServeBase):
 
345
 
 
346
    def test_serve_tcp(self):
 
347
        """'bzr serve' wraps the given --directory in a ChrootServer.
 
348
 
 
349
        So requests that search up through the parent directories (like
 
350
        find_repositoryV3) will give "not found" responses, rather than
 
351
        InvalidURLJoin or jail break errors.
 
352
        """
 
353
        t = self.get_transport()
 
354
        t.mkdir('server-root')
 
355
        self.run_bzr_serve_then_func(
 
356
            ['--listen', '127.0.0.1', '--port', '0',
 
357
             '--directory', t.local_abspath('server-root'),
 
358
             '--allow-writes'],
 
359
            func=self.when_server_started)
 
360
        # The when_server_started method issued a find_repositoryV3 that should
 
361
        # fail with 'norepository' because there are no repositories inside the
 
362
        # --directory.
 
363
        self.assertEqual(('norepository',), self.client_resp)
 
364
 
 
365
    def when_server_started(self):
 
366
        # Connect to the TCP server and issue some requests and see what comes
 
367
        # back.
 
368
        client_medium = medium.SmartTCPClientMedium(
 
369
            '127.0.0.1', self.tcp_server.port,
 
370
            'bzr://localhost:%d/' % (self.tcp_server.port,))
 
371
        smart_client = client._SmartClient(client_medium)
 
372
        resp = smart_client.call('mkdir', 'foo', '')
 
373
        resp = smart_client.call('BzrDirFormat.initialize', 'foo/')
209
374
        try:
210
 
            if sys.platform == 'win32':
211
 
                path_to_branch = os.path.splitdrive(path_to_branch)[1]
212
 
            branch = Branch.open(
213
 
                'bzr+ssh://fred:secret@localhost:%d%s' % (port, path_to_branch))
214
 
            self.make_read_requests(branch)
215
 
            # Check we can perform write operations
216
 
            branch.bzrdir.root_transport.mkdir('foo')
217
 
        finally:
218
 
            # Restore the BZR_REMOTE_PATH environment variable back to its
219
 
            # original state.
220
 
            if orig_bzr_remote_path is None:
221
 
                del os.environ['BZR_REMOTE_PATH']
222
 
            else:
223
 
                os.environ['BZR_REMOTE_PATH'] = orig_bzr_remote_path
224
 
 
225
 
        self.assertEqual(
226
 
            ['%s serve --inet --directory=/ --allow-writes'
227
 
             % bzr_remote_path],
228
 
            self.command_executed)
229
 
        
 
375
            resp = smart_client.call('BzrDir.find_repositoryV3', 'foo/')
 
376
        except errors.ErrorFromSmartServer, e:
 
377
            resp = e.error_tuple
 
378
        self.client_resp = resp
 
379
        client_medium.disconnect()
 
380
 
 
381
 
 
382
class TestUserdirExpansion(TestCaseWithMemoryTransport):
 
383
 
 
384
    @staticmethod
 
385
    def fake_expanduser(path):
 
386
        """A simple, environment-independent, function for the duration of this
 
387
        test.
 
388
 
 
389
        Paths starting with a path segment of '~user' will expand to start with
 
390
        '/home/user/'.  Every other path will be unchanged.
 
391
        """
 
392
        if path.split('/', 1)[0] == '~user':
 
393
            return '/home/user' + path[len('~user'):]
 
394
        return path
 
395
 
 
396
    def make_test_server(self, base_path='/'):
 
397
        """Make and start a BzrServerFactory, backed by a memory transport, and
 
398
        creat '/home/user' in that transport.
 
399
        """
 
400
        bzr_server = BzrServerFactory(
 
401
            self.fake_expanduser, lambda t: base_path)
 
402
        mem_transport = self.get_transport()
 
403
        mem_transport.mkdir_multi(['home', 'home/user'])
 
404
        bzr_server.set_up(mem_transport, None, None, inet=True, timeout=4.0)
 
405
        self.addCleanup(bzr_server.tear_down)
 
406
        return bzr_server
 
407
 
 
408
    def test_bzr_serve_expands_userdir(self):
 
409
        bzr_server = self.make_test_server()
 
410
        self.assertTrue(bzr_server.smart_server.backing_transport.has('~user'))
 
411
 
 
412
    def test_bzr_serve_does_not_expand_userdir_outside_base(self):
 
413
        bzr_server = self.make_test_server('/foo')
 
414
        self.assertFalse(bzr_server.smart_server.backing_transport.has('~user'))
 
415
 
 
416
    def test_get_base_path(self):
 
417
        """cmd_serve will turn the --directory option into a LocalTransport
 
418
        (optionally decorated with 'readonly+').  BzrServerFactory can
 
419
        determine the original --directory from that transport.
 
420
        """
 
421
        # URLs always include the trailing slash, and get_base_path returns it
 
422
        base_dir = osutils.abspath('/a/b/c') + '/'
 
423
        base_url = urlutils.local_path_to_url(base_dir) + '/'
 
424
        # Define a fake 'protocol' to capture the transport that cmd_serve
 
425
        # passes to serve_bzr.
 
426
        def capture_transport(transport, host, port, inet, timeout):
 
427
            self.bzr_serve_transport = transport
 
428
        cmd = builtins.cmd_serve()
 
429
        # Read-only
 
430
        cmd.run(directory=base_dir, protocol=capture_transport)
 
431
        server_maker = BzrServerFactory()
 
432
        self.assertEqual(
 
433
            'readonly+%s' % base_url, self.bzr_serve_transport.base)
 
434
        self.assertEqual(
 
435
            base_dir, server_maker.get_base_path(self.bzr_serve_transport))
 
436
        # Read-write
 
437
        cmd.run(directory=base_dir, protocol=capture_transport,
 
438
            allow_writes=True)
 
439
        server_maker = BzrServerFactory()
 
440
        self.assertEqual(base_url, self.bzr_serve_transport.base)
 
441
        self.assertEqual(base_dir,
 
442
            server_maker.get_base_path(self.bzr_serve_transport))
 
443
        # Read-only, from a URL
 
444
        cmd.run(directory=base_url, protocol=capture_transport)
 
445
        server_maker = BzrServerFactory()
 
446
        self.assertEqual(
 
447
            'readonly+%s' % base_url, self.bzr_serve_transport.base)
 
448
        self.assertEqual(
 
449
            base_dir, server_maker.get_base_path(self.bzr_serve_transport))