~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: 2008-09-23 17:00:03 UTC
  • mto: This revision was merged to the branch mainline in revision 3728.
  • Revision ID: aaron@aaronbentley.com-20080923170003-8vh06dg6jewct4ta
Correct spelling of 'Application Data'

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
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."""
136
48
        result = self.finish_bzr_subprocess(process)
137
49
        self.assertEqual('', result[0])
138
50
        self.assertEqual('', result[1])
139
 
 
 
51
    
140
52
    def assertServerFinishesCleanly(self, process):
141
53
        """Shutdown the bzr serve instance process looking for errors."""
142
54
        # Shutdown the server
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)
188
97
        args = ['serve', '--port', 'localhost:0']
189
98
        args.extend(extra_options)
190
99
        process = self.start_bzr_subprocess(args, skip_if_plan_to_signal=True)
191
 
        port_line = process.stderr.readline()
 
100
        port_line = process.stdout.readline()
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_from_url(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):
239
138
        self.make_read_requests(branch)
240
139
        self.assertServerFinishesCleanly(process)
241
140
 
242
 
    def test_bzr_serve_supports_protocol(self):
 
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
        
243
152
        # Make a branch
244
 
        self.make_branch('.')
245
 
 
246
 
        process, url = self.start_server_port(['--allow-writes',
247
 
                                               '--protocol=bzr'])
248
 
 
249
 
        # Connect to the server
250
 
        branch = Branch.open(url)
251
 
        self.make_read_requests(branch)
252
 
        self.assertServerFinishesCleanly(process)
253
 
 
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/')
 
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
300
209
        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))
 
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