← 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: Aaron Bentley
  • Date: 2009-06-19 21:16:31 UTC
  • mto: This revision was merged to the branch mainline in revision 4481.
  • Revision ID: aaron@aaronbentley.com-20090619211631-4fnkv2uui98xj7ux
Provide control over switch and shelver messaging.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_serve.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006 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
19
19
 
20
20
import os
21
21
import signal
 
22
import subprocess
22
23
import sys
23
 
import thread
24
24
import threading
25
25
 
26
26
from bzrlib import (
27
 
    builtins,
28
27
    errors,
29
28
    osutils,
30
29
    revision as _mod_revision,
31
 
    trace,
32
 
    transport,
33
 
    urlutils,
34
30
    )
35
31
from bzrlib.branch import Branch
36
32
from bzrlib.bzrdir import BzrDir
37
 
from bzrlib.smart import client, medium
38
 
from bzrlib.smart.server import (
39
 
    BzrServerFactory,
40
 
    SmartTCPServer,
41
 
    )
42
 
from bzrlib.tests import (
43
 
    TestCaseWithMemoryTransport,
44
 
    TestCaseWithTransport,
45
 
    )
46
 
from bzrlib.transport import remote
47
 
 
48
 
 
49
 
class TestBzrServeBase(TestCaseWithTransport):
50
 
 
51
 
    def run_bzr_serve_then_func(self, serve_args, retcode=0, func=None,
52
 
                                *func_args, **func_kwargs):
53
 
        """Run 'bzr serve', and run the given func in a thread once the server
54
 
        has started.
55
 
 
56
 
        When 'func' terminates, the server will be terminated too.
57
 
 
58
 
        Returns stdout and stderr.
59
 
        """
60
 
        def on_server_start_thread(tcp_server):
61
 
            """This runs concurrently with the server thread.
62
 
 
63
 
            The server is interrupted as soon as ``func`` finishes, even if an
64
 
            exception is encountered.
65
 
            """
66
 
            try:
67
 
                # Run func if set
68
 
                self.tcp_server = tcp_server
69
 
                if not func is None:
70
 
                    try:
71
 
                        func(*func_args, **func_kwargs)
72
 
                    except Exception, e:
73
 
                        # Log errors to make some test failures a little less
74
 
                        # mysterious.
75
 
                        trace.mutter('func broke: %r', e)
76
 
            finally:
77
 
                # Then stop the server
78
 
                trace.mutter('interrupting...')
79
 
                thread.interrupt_main()
80
 
        # When the hook is fired, it just starts ``on_server_start_thread`` and
81
 
        # return
82
 
        def on_server_start(backing_urls, tcp_server):
83
 
            t = threading.Thread(
84
 
                target=on_server_start_thread, args=(tcp_server,))
85
 
            t.start()
86
 
        # install hook
87
 
        SmartTCPServer.hooks.install_named_hook(
88
 
            'server_started_ex', on_server_start,
89
 
            'run_bzr_serve_then_func hook')
90
 
        # start a TCP server
91
 
        try:
92
 
            out, err = self.run_bzr(['serve'] + list(serve_args),
93
 
                                    retcode=retcode)
94
 
        except KeyboardInterrupt, e:
95
 
            out, err = e.args
96
 
        return out, err
97
 
 
98
 
 
99
 
class TestBzrServe(TestBzrServeBase):
100
 
 
101
 
    def setUp(self):
102
 
        super(TestBzrServe, self).setUp()
103
 
        self.disable_missing_extensions_warning()
104
 
 
105
 
    def test_server_exception_with_hook(self):
106
 
        """Catch exception from the server in the server_exception hook.
107
 
 
108
 
        We use ``run_bzr_serve_then_func`` without a ``func`` so the server
109
 
        will receive a KeyboardInterrupt exception we want to catch.
110
 
        """
111
 
        def hook(exception):
112
 
            if exception[0] is KeyboardInterrupt:
113
 
                sys.stderr.write('catching KeyboardInterrupt\n')
114
 
                return True
115
 
            else:
116
 
                return False
117
 
        SmartTCPServer.hooks.install_named_hook(
118
 
            'server_exception', hook,
119
 
            'test_server_except_hook hook')
120
 
        args = ['--port', 'localhost:0', '--quiet']
121
 
        out, err = self.run_bzr_serve_then_func(args, retcode=0)
122
 
        self.assertEqual('catching KeyboardInterrupt\n', err)
123
 
 
124
 
    def test_server_exception_no_hook(self):
125
 
        """test exception without hook returns error"""
126
 
        args = []
127
 
        out, err = self.run_bzr_serve_then_func(args, retcode=3)
 
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):
128
40
 
129
41
    def assertInetServerShutsdownCleanly(self, process):
130
42
        """Shutdown the server process looking for errors."""
163
75
            finish_bzr_subprocess, a client for the server, and a transport.
164
76
        """
165
77
        # Serve from the current directory
166
 
        args = ['serve', '--inet']
167
 
        args.extend(extra_options)
168
 
        process = self.start_bzr_subprocess(args)
 
78
        process = self.start_bzr_subprocess(['serve', '--inet'])
169
79
 
170
80
        # Connect to the server
171
81
        # We use this url because while this is no valid URL to connect to this
172
82
        # server instance, the transport needs a URL.
173
83
        url = 'bzr://localhost/'
174
 
        self.permit_url(url)
175
84
        client_medium = medium.SmartSimplePipesClientMedium(
176
85
            process.stdout, process.stdin, url)
177
86
        transport = remote.RemoteTransport(url, medium=client_medium)
192
101
        prefix = 'listening on port: '
193
102
        self.assertStartsWith(port_line, prefix)
194
103
        port = int(port_line[len(prefix):])
195
 
        url = 'bzr://localhost:%d/' % port
196
 
        self.permit_url(url)
197
 
        return process, url
198
 
 
199
 
    def test_bzr_serve_quiet(self):
200
 
        self.make_branch('.')
201
 
        args = ['--port', 'localhost:0', '--quiet']
202
 
        out, err = self.run_bzr_serve_then_func(args, retcode=3)
203
 
        self.assertEqual('', out)
204
 
        self.assertEqual('', err)
 
104
        return process,'bzr://localhost:%d/' % port
205
105
 
206
106
    def test_bzr_serve_inet_readonly(self):
207
107
        """bzr server should provide a read only filesystem by default."""
215
115
 
216
116
        process, transport = self.start_server_inet(['--allow-writes'])
217
117
 
218
 
        # We get a working branch, and can create a directory
 
118
        # We get a working branch
219
119
        branch = BzrDir.open_from_transport(transport).open_branch()
220
120
        self.make_read_requests(branch)
221
 
        transport.mkdir('adir')
222
121
        self.assertInetServerShutsdownCleanly(process)
223
122
 
224
123
    def test_bzr_serve_port_readonly(self):
225
124
        """bzr server should provide a read only filesystem by default."""
226
125
        process, url = self.start_server_port()
227
 
        t = transport.get_transport(url)
228
 
        self.assertRaises(errors.TransportNotPossible, t.mkdir, 'adir')
 
126
        transport = get_transport(url)
 
127
        self.assertRaises(errors.TransportNotPossible, transport.mkdir, 'adir')
229
128
        self.assertServerFinishesCleanly(process)
230
129
 
231
130
    def test_bzr_serve_port_readwrite(self):
251
150
        self.make_read_requests(branch)
252
151
        self.assertServerFinishesCleanly(process)
253
152
 
254
 
    def test_bzr_serve_dhpss(self):
255
 
        # This is a smoke test that the server doesn't crash when run with
256
 
        # -Dhpss, and does drop some hpss logging to the file.
257
 
        self.make_branch('.')
258
 
        log_fname = os.getcwd() + '/server.log'
259
 
        self.overrideEnv('BZR_LOG', log_fname)
260
 
        process, transport = self.start_server_inet(['-Dhpss'])
261
 
        branch = BzrDir.open_from_transport(transport).open_branch()
262
 
        self.make_read_requests(branch)
263
 
        self.assertInetServerShutsdownCleanly(process)
264
 
        f = open(log_fname, 'rb')
265
 
        content = f.read()
266
 
        f.close()
267
 
        self.assertContainsRe(content, r'hpss request: \[[0-9-]+\]')
268
 
 
269
 
 
270
 
class TestCmdServeChrooting(TestBzrServeBase):
271
 
 
272
 
    def test_serve_tcp(self):
273
 
        """'bzr serve' wraps the given --directory in a ChrootServer.
274
 
 
275
 
        So requests that search up through the parent directories (like
276
 
        find_repositoryV3) will give "not found" responses, rather than
277
 
        InvalidURLJoin or jail break errors.
278
 
        """
279
 
        t = self.get_transport()
280
 
        t.mkdir('server-root')
281
 
        self.run_bzr_serve_then_func(
282
 
            ['--port', '127.0.0.1:0',
283
 
             '--directory', t.local_abspath('server-root'),
284
 
             '--allow-writes'],
285
 
            func=self.when_server_started)
286
 
        # The when_server_started method issued a find_repositoryV3 that should
287
 
        # fail with 'norepository' because there are no repositories inside the
288
 
        # --directory.
289
 
        self.assertEqual(('norepository',), self.client_resp)
290
 
 
291
 
    def when_server_started(self):
292
 
        # Connect to the TCP server and issue some requests and see what comes
293
 
        # back.
294
 
        client_medium = medium.SmartTCPClientMedium(
295
 
            '127.0.0.1', self.tcp_server.port,
296
 
            'bzr://localhost:%d/' % (self.tcp_server.port,))
297
 
        smart_client = client._SmartClient(client_medium)
298
 
        resp = smart_client.call('mkdir', 'foo', '')
299
 
        resp = smart_client.call('BzrDirFormat.initialize', 'foo/')
300
 
        try:
301
 
            resp = smart_client.call('BzrDir.find_repositoryV3', 'foo/')
302
 
        except errors.ErrorFromSmartServer, e:
303
 
            resp = e.error_tuple
304
 
        self.client_resp = resp
305
 
        client_medium.disconnect()
306
 
 
307
 
 
308
 
class TestUserdirExpansion(TestCaseWithMemoryTransport):
309
 
 
310
 
    @staticmethod
311
 
    def fake_expanduser(path):
312
 
        """A simple, environment-independent, function for the duration of this
313
 
        test.
314
 
 
315
 
        Paths starting with a path segment of '~user' will expand to start with
316
 
        '/home/user/'.  Every other path will be unchanged.
317
 
        """
318
 
        if path.split('/', 1)[0] == '~user':
319
 
            return '/home/user' + path[len('~user'):]
320
 
        return path
321
 
 
322
 
    def make_test_server(self, base_path='/'):
323
 
        """Make and start a BzrServerFactory, backed by a memory transport, and
324
 
        creat '/home/user' in that transport.
325
 
        """
326
 
        bzr_server = BzrServerFactory(
327
 
            self.fake_expanduser, lambda t: base_path)
328
 
        mem_transport = self.get_transport()
329
 
        mem_transport.mkdir_multi(['home', 'home/user'])
330
 
        bzr_server.set_up(mem_transport, None, None, inet=True)
331
 
        self.addCleanup(bzr_server.tear_down)
332
 
        return bzr_server
333
 
 
334
 
    def test_bzr_serve_expands_userdir(self):
335
 
        bzr_server = self.make_test_server()
336
 
        self.assertTrue(bzr_server.smart_server.backing_transport.has('~user'))
337
 
 
338
 
    def test_bzr_serve_does_not_expand_userdir_outside_base(self):
339
 
        bzr_server = self.make_test_server('/foo')
340
 
        self.assertFalse(bzr_server.smart_server.backing_transport.has('~user'))
341
 
 
342
 
    def test_get_base_path(self):
343
 
        """cmd_serve will turn the --directory option into a LocalTransport
344
 
        (optionally decorated with 'readonly+').  BzrServerFactory can
345
 
        determine the original --directory from that transport.
346
 
        """
347
 
        # URLs always include the trailing slash, and get_base_path returns it
348
 
        base_dir = osutils.abspath('/a/b/c') + '/'
349
 
        base_url = urlutils.local_path_to_url(base_dir) + '/'
350
 
        # Define a fake 'protocol' to capture the transport that cmd_serve
351
 
        # passes to serve_bzr.
352
 
        def capture_transport(transport, host, port, inet):
353
 
            self.bzr_serve_transport = transport
354
 
        cmd = builtins.cmd_serve()
355
 
        # Read-only
356
 
        cmd.run(directory=base_dir, protocol=capture_transport)
357
 
        server_maker = BzrServerFactory()
358
 
        self.assertEqual(
359
 
            'readonly+%s' % base_url, self.bzr_serve_transport.base)
360
 
        self.assertEqual(
361
 
            base_dir, server_maker.get_base_path(self.bzr_serve_transport))
362
 
        # Read-write
363
 
        cmd.run(directory=base_dir, protocol=capture_transport,
364
 
            allow_writes=True)
365
 
        server_maker = BzrServerFactory()
366
 
        self.assertEqual(base_url, self.bzr_serve_transport.base)
367
 
        self.assertEqual(base_dir,
368
 
            server_maker.get_base_path(self.bzr_serve_transport))
 
153
    def test_bzr_connect_to_bzr_ssh(self):
 
154
        """User acceptance that get_transport of a bzr+ssh:// behaves correctly.
 
155
 
 
156
        bzr+ssh:// should cause bzr to run a remote bzr smart server over SSH.
 
157
        """
 
158
        try:
 
159
            from bzrlib.transport.sftp import SFTPServer
 
160
        except ParamikoNotPresent:
 
161
            raise TestSkipped('Paramiko not installed')
 
162
        from bzrlib.tests.stub_sftp import StubServer
 
163
 
 
164
        # Make a branch
 
165
        self.make_branch('a_branch')
 
166
 
 
167
        # Start an SSH server
 
168
        self.command_executed = []
 
169
        # XXX: This is horrible -- we define a really dumb SSH server that
 
170
        # executes commands, and manage the hooking up of stdin/out/err to the
 
171
        # SSH channel ourselves.  Surely this has already been implemented
 
172
        # elsewhere?
 
173
        class StubSSHServer(StubServer):
 
174
 
 
175
            test = self
 
176
 
 
177
            def check_channel_exec_request(self, channel, command):
 
178
                self.test.command_executed.append(command)
 
179
                proc = subprocess.Popen(
 
180
                    command, shell=True, stdin=subprocess.PIPE,
 
181
                    stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 
182
 
 
183
                # XXX: horribly inefficient, not to mention ugly.
 
184
                # Start a thread for each of stdin/out/err, and relay bytes from
 
185
                # the subprocess to channel and vice versa.
 
186
                def ferry_bytes(read, write, close):
 
187
                    while True:
 
188
                        bytes = read(1)
 
189
                        if bytes == '':
 
190
                            close()
 
191
                            break
 
192
                        write(bytes)
 
193
 
 
194
                file_functions = [
 
195
                    (channel.recv, proc.stdin.write, proc.stdin.close),
 
196
                    (proc.stdout.read, channel.sendall, channel.close),
 
197
                    (proc.stderr.read, channel.sendall_stderr, channel.close)]
 
198
                for read, write, close in file_functions:
 
199
                    t = threading.Thread(
 
200
                        target=ferry_bytes, args=(read, write, close))
 
201
                    t.start()
 
202
 
 
203
                return True
 
204
 
 
205
        ssh_server = SFTPServer(StubSSHServer)
 
206
        # XXX: We *don't* want to override the default SSH vendor, so we set
 
207
        # _vendor to what _get_ssh_vendor returns.
 
208
        ssh_server.setUp()
 
209
        self.addCleanup(ssh_server.tearDown)
 
210
        port = ssh_server._listener.port
 
211
 
 
212
        # Access the branch via a bzr+ssh URL.  The BZR_REMOTE_PATH environment
 
213
        # variable is used to tell bzr what command to run on the remote end.
 
214
        path_to_branch = osutils.abspath('a_branch')
 
215
 
 
216
        orig_bzr_remote_path = os.environ.get('BZR_REMOTE_PATH')
 
217
        bzr_remote_path = self.get_bzr_path()
 
218
        if sys.platform == 'win32':
 
219
            bzr_remote_path = sys.executable + ' ' + self.get_bzr_path()
 
220
        os.environ['BZR_REMOTE_PATH'] = bzr_remote_path
 
221
        try:
 
222
            if sys.platform == 'win32':
 
223
                path_to_branch = os.path.splitdrive(path_to_branch)[1]
 
224
            branch = Branch.open(
 
225
                'bzr+ssh://fred:secret@localhost:%d%s' % (port, path_to_branch))
 
226
            self.make_read_requests(branch)
 
227
            # Check we can perform write operations
 
228
            branch.bzrdir.root_transport.mkdir('foo')
 
229
        finally:
 
230
            # Restore the BZR_REMOTE_PATH environment variable back to its
 
231
            # original state.
 
232
            if orig_bzr_remote_path is None:
 
233
                del os.environ['BZR_REMOTE_PATH']
 
234
            else:
 
235
                os.environ['BZR_REMOTE_PATH'] = orig_bzr_remote_path
 
236
 
 
237
        self.assertEqual(
 
238
            ['%s serve --inet --directory=/ --allow-writes'
 
239
             % bzr_remote_path],
 
240
            self.command_executed)
 
241