← 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

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

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-2010 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
18
18
"""Tests of the bzr serve command."""
19
19
 
20
20
import os
 
21
import os.path
21
22
import signal
22
23
import subprocess
23
24
import sys
 
25
import thread
24
26
import threading
25
27
 
26
28
from bzrlib import (
 
29
    builtins,
 
30
    debug,
27
31
    errors,
28
32
    osutils,
29
33
    revision as _mod_revision,
 
34
    transport,
 
35
    urlutils,
30
36
    )
31
37
from bzrlib.branch import Branch
32
38
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):
 
39
from bzrlib.smart import client, medium
 
40
from bzrlib.smart.server import BzrServerFactory, SmartTCPServer
 
41
from bzrlib.tests import (
 
42
    TestCaseWithMemoryTransport,
 
43
    TestCaseWithTransport,
 
44
    TestSkipped,
 
45
    )
 
46
from bzrlib.trace import mutter
 
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
        # install hook
 
62
        def on_server_start(backing_urls, tcp_server):
 
63
            t = threading.Thread(
 
64
                target=on_server_start_thread, args=(tcp_server,))
 
65
            t.start()
 
66
        def on_server_start_thread(tcp_server):
 
67
            try:
 
68
                # Run func if set
 
69
                self.tcp_server = tcp_server
 
70
                if not func is 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
                        mutter('func broke: %r', e)
 
77
            finally:
 
78
                # Then stop the server
 
79
                mutter('interrupting...')
 
80
                thread.interrupt_main()
 
81
        SmartTCPServer.hooks.install_named_hook(
 
82
            'server_started_ex', on_server_start,
 
83
            'run_bzr_serve_then_func hook')
 
84
        # start a TCP server
 
85
        try:
 
86
            out, err = self.run_bzr(['serve'] + list(serve_args))
 
87
        except KeyboardInterrupt, e:
 
88
            out, err = e.args
 
89
        return out, err
 
90
 
 
91
 
 
92
class TestBzrServe(TestBzrServeBase):
 
93
 
 
94
    def setUp(self):
 
95
        super(TestBzrServe, self).setUp()
 
96
        self.disable_missing_extensions_warning()
40
97
 
41
98
    def assertInetServerShutsdownCleanly(self, process):
42
99
        """Shutdown the server process looking for errors."""
75
132
            finish_bzr_subprocess, a client for the server, and a transport.
76
133
        """
77
134
        # Serve from the current directory
78
 
        process = self.start_bzr_subprocess(['serve', '--inet'])
 
135
        args = ['serve', '--inet']
 
136
        args.extend(extra_options)
 
137
        process = self.start_bzr_subprocess(args)
79
138
 
80
139
        # Connect to the server
81
140
        # We use this url because while this is no valid URL to connect to this
82
141
        # server instance, the transport needs a URL.
83
142
        url = 'bzr://localhost/'
 
143
        self.permit_url(url)
84
144
        client_medium = medium.SmartSimplePipesClientMedium(
85
145
            process.stdout, process.stdin, url)
86
146
        transport = remote.RemoteTransport(url, medium=client_medium)
101
161
        prefix = 'listening on port: '
102
162
        self.assertStartsWith(port_line, prefix)
103
163
        port = int(port_line[len(prefix):])
104
 
        return process,'bzr://localhost:%d/' % port
 
164
        url = 'bzr://localhost:%d/' % port
 
165
        self.permit_url(url)
 
166
        return process, url
 
167
    
 
168
    def test_bzr_serve_quiet(self):
 
169
        self.make_branch('.')
 
170
        args = ['--port', 'localhost:0', '--quiet']
 
171
        out, err = self.run_bzr_serve_then_func(args, retcode=3)
 
172
        self.assertEqual('', out)
 
173
        self.assertEqual('', err)
105
174
 
106
175
    def test_bzr_serve_inet_readonly(self):
107
176
        """bzr server should provide a read only filesystem by default."""
115
184
 
116
185
        process, transport = self.start_server_inet(['--allow-writes'])
117
186
 
118
 
        # We get a working branch
 
187
        # We get a working branch, and can create a directory
119
188
        branch = BzrDir.open_from_transport(transport).open_branch()
120
189
        self.make_read_requests(branch)
 
190
        transport.mkdir('adir')
121
191
        self.assertInetServerShutsdownCleanly(process)
122
192
 
123
193
    def test_bzr_serve_port_readonly(self):
124
194
        """bzr server should provide a read only filesystem by default."""
125
195
        process, url = self.start_server_port()
126
 
        transport = get_transport(url)
127
 
        self.assertRaises(errors.TransportNotPossible, transport.mkdir, 'adir')
 
196
        t = transport.get_transport(url)
 
197
        self.assertRaises(errors.TransportNotPossible, t.mkdir, 'adir')
128
198
        self.assertServerFinishesCleanly(process)
129
199
 
130
200
    def test_bzr_serve_port_readwrite(self):
138
208
        self.make_read_requests(branch)
139
209
        self.assertServerFinishesCleanly(process)
140
210
 
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
 
 
 
211
    def test_bzr_serve_supports_protocol(self):
152
212
        # 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
 
213
        self.make_branch('.')
 
214
 
 
215
        process, url = self.start_server_port(['--allow-writes',
 
216
                                               '--protocol=bzr'])
 
217
 
 
218
        # Connect to the server
 
219
        branch = Branch.open(url)
 
220
        self.make_read_requests(branch)
 
221
        self.assertServerFinishesCleanly(process)
 
222
 
 
223
    def test_bzr_serve_dhpss(self):
 
224
        # This is a smoke test that the server doesn't crash when run with
 
225
        # -Dhpss, and does drop some hpss logging to the file.
 
226
        self.make_branch('.')
 
227
        log_fname = os.getcwd() + '/server.log'
 
228
        self._captureVar('BZR_LOG', log_fname)
 
229
        process, transport = self.start_server_inet(['-Dhpss'])
 
230
        branch = BzrDir.open_from_transport(transport).open_branch()
 
231
        self.make_read_requests(branch)
 
232
        self.assertInetServerShutsdownCleanly(process)
 
233
        f = open(log_fname, 'rb')
 
234
        content = f.read()
 
235
        f.close()
 
236
        self.assertContainsRe(content, r'hpss request: \[[0-9-]+\]')
 
237
 
 
238
 
 
239
class TestCmdServeChrooting(TestBzrServeBase):
 
240
 
 
241
    def test_serve_tcp(self):
 
242
        """'bzr serve' wraps the given --directory in a ChrootServer.
 
243
 
 
244
        So requests that search up through the parent directories (like
 
245
        find_repositoryV3) will give "not found" responses, rather than
 
246
        InvalidURLJoin or jail break errors.
 
247
        """
 
248
        t = self.get_transport()
 
249
        t.mkdir('server-root')
 
250
        self.run_bzr_serve_then_func(
 
251
            ['--port', '127.0.0.1:0',
 
252
             '--directory', t.local_abspath('server-root'),
 
253
             '--allow-writes'],
 
254
            func=self.when_server_started)
 
255
        # The when_server_started method issued a find_repositoryV3 that should
 
256
        # fail with 'norepository' because there are no repositories inside the
 
257
        # --directory.
 
258
        self.assertEqual(('norepository',), self.client_resp)
 
259
 
 
260
    def when_server_started(self):
 
261
        # Connect to the TCP server and issue some requests and see what comes
 
262
        # back.
 
263
        client_medium = medium.SmartTCPClientMedium(
 
264
            '127.0.0.1', self.tcp_server.port,
 
265
            'bzr://localhost:%d/' % (self.tcp_server.port,))
 
266
        smart_client = client._SmartClient(client_medium)
 
267
        resp = smart_client.call('mkdir', 'foo', '')
 
268
        resp = smart_client.call('BzrDirFormat.initialize', 'foo/')
209
269
        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)
 
270
            resp = smart_client.call('BzrDir.find_repositoryV3', 'foo/')
 
271
        except errors.ErrorFromSmartServer, e:
 
272
            resp = e.error_tuple
 
273
        self.client_resp = resp
 
274
        client_medium.disconnect()
 
275
 
 
276
 
 
277
class TestUserdirExpansion(TestCaseWithMemoryTransport):
 
278
 
 
279
    def fake_expanduser(self, path):
 
280
        """A simple, environment-independent, function for the duration of this
 
281
        test.
 
282
 
 
283
        Paths starting with a path segment of '~user' will expand to start with
 
284
        '/home/user/'.  Every other path will be unchanged.
 
285
        """
 
286
        if path.split('/', 1)[0] == '~user':
 
287
            return '/home/user' + path[len('~user'):]
 
288
        return path
 
289
 
 
290
    def make_test_server(self, base_path='/'):
 
291
        """Make and start a BzrServerFactory, backed by a memory transport, and
 
292
        creat '/home/user' in that transport.
 
293
        """
 
294
        bzr_server = BzrServerFactory(
 
295
            self.fake_expanduser, lambda t: base_path)
 
296
        mem_transport = self.get_transport()
 
297
        mem_transport.mkdir_multi(['home', 'home/user'])
 
298
        bzr_server.set_up(mem_transport, None, None, inet=True)
 
299
        self.addCleanup(bzr_server.tear_down)
 
300
        return bzr_server
 
301
 
 
302
    def test_bzr_serve_expands_userdir(self):
 
303
        bzr_server = self.make_test_server()
 
304
        self.assertTrue(bzr_server.smart_server.backing_transport.has('~user'))
 
305
 
 
306
    def test_bzr_serve_does_not_expand_userdir_outside_base(self):
 
307
        bzr_server = self.make_test_server('/foo')
 
308
        self.assertFalse(bzr_server.smart_server.backing_transport.has('~user'))
 
309
 
 
310
    def test_get_base_path(self):
 
311
        """cmd_serve will turn the --directory option into a LocalTransport
 
312
        (optionally decorated with 'readonly+').  BzrServerFactory can
 
313
        determine the original --directory from that transport.
 
314
        """
 
315
        # URLs always include the trailing slash, and get_base_path returns it
 
316
        base_dir = osutils.abspath('/a/b/c') + '/'
 
317
        base_url = urlutils.local_path_to_url(base_dir) + '/'
 
318
        # Define a fake 'protocol' to capture the transport that cmd_serve
 
319
        # passes to serve_bzr.
 
320
        def capture_transport(transport, host, port, inet):
 
321
            self.bzr_serve_transport = transport
 
322
        cmd = builtins.cmd_serve()
 
323
        # Read-only
 
324
        cmd.run(directory=base_dir, protocol=capture_transport)
 
325
        server_maker = BzrServerFactory()
 
326
        self.assertEqual(
 
327
            'readonly+%s' % base_url, self.bzr_serve_transport.base)
 
328
        self.assertEqual(
 
329
            base_dir, server_maker.get_base_path(self.bzr_serve_transport))
 
330
        # Read-write
 
331
        cmd.run(directory=base_dir, protocol=capture_transport,
 
332
            allow_writes=True)
 
333
        server_maker = BzrServerFactory()
 
334
        self.assertEqual(base_url, self.bzr_serve_transport.base)
 
335
        self.assertEqual(base_dir,
 
336
            server_maker.get_base_path(self.bzr_serve_transport))
229
337