/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 bzrlib/tests/blackbox/test_serve.py

  • Committer: John Arbash Meinel
  • Date: 2009-12-10 17:16:19 UTC
  • mfrom: (4884 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4889.
  • Revision ID: john@arbash-meinel.com-20091210171619-ehdcxjbl8afhq9g1
Bring in bzr.dev 4884

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_serve.py
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
26
import threading
26
27
 
27
28
from bzrlib import (
 
29
    builtins,
28
30
    errors,
29
31
    osutils,
30
32
    revision as _mod_revision,
31
 
    transport,
 
33
    urlutils,
32
34
    )
33
35
from bzrlib.branch import Branch
34
36
from bzrlib.bzrdir import BzrDir
35
 
from bzrlib.errors import ParamikoNotPresent
36
37
from bzrlib.smart import client, medium
37
 
from bzrlib.smart.server import SmartTCPServer
38
 
from bzrlib.tests import TestCaseWithTransport, TestSkipped
 
38
from bzrlib.smart.server import BzrServerFactory, SmartTCPServer
 
39
from bzrlib.tests import (
 
40
    ParamikoFeature,
 
41
    TestCaseWithMemoryTransport,
 
42
    TestCaseWithTransport,
 
43
    TestSkipped,
 
44
    )
39
45
from bzrlib.trace import mutter
40
46
from bzrlib.transport import get_transport, remote
41
47
 
42
 
 
43
 
class TestBzrServe(TestCaseWithTransport):
 
48
class TestBzrServeBase(TestCaseWithTransport):
 
49
 
 
50
    def run_bzr_serve_then_func(self, serve_args, retcode=0, func=None,
 
51
                                *func_args, **func_kwargs):
 
52
        """Run 'bzr serve', and run the given func in a thread once the server
 
53
        has started.
 
54
        
 
55
        When 'func' terminates, the server will be terminated too.
 
56
        
 
57
        Returns stdout and stderr.
 
58
        """
 
59
        # install hook
 
60
        def on_server_start(backing_urls, tcp_server):
 
61
            t = threading.Thread(
 
62
                target=on_server_start_thread, args=(tcp_server,))
 
63
            t.start()
 
64
        def on_server_start_thread(tcp_server):
 
65
            try:
 
66
                # Run func if set
 
67
                self.tcp_server = tcp_server
 
68
                if not func is None:
 
69
                    try:
 
70
                        func(*func_args, **func_kwargs)
 
71
                    except Exception, e:
 
72
                        # Log errors to make some test failures a little less
 
73
                        # mysterious.
 
74
                        mutter('func broke: %r', e)
 
75
            finally:
 
76
                # Then stop the server
 
77
                mutter('interrupting...')
 
78
                thread.interrupt_main()
 
79
        SmartTCPServer.hooks.install_named_hook(
 
80
            'server_started_ex', on_server_start,
 
81
            'run_bzr_serve_then_func hook')
 
82
        # start a TCP server
 
83
        try:
 
84
            out, err = self.run_bzr(['serve'] + list(serve_args))
 
85
        except KeyboardInterrupt, e:
 
86
            out, err = e.args
 
87
        return out, err
 
88
 
 
89
 
 
90
class TestBzrServe(TestBzrServeBase):
 
91
 
 
92
    def setUp(self):
 
93
        super(TestBzrServe, self).setUp()
 
94
        self.disable_missing_extensions_warning()
44
95
 
45
96
    def assertInetServerShutsdownCleanly(self, process):
46
97
        """Shutdown the server process looking for errors."""
85
136
        # We use this url because while this is no valid URL to connect to this
86
137
        # server instance, the transport needs a URL.
87
138
        url = 'bzr://localhost/'
 
139
        self.permit_url(url)
88
140
        client_medium = medium.SmartSimplePipesClientMedium(
89
141
            process.stdout, process.stdin, url)
90
142
        transport = remote.RemoteTransport(url, medium=client_medium)
105
157
        prefix = 'listening on port: '
106
158
        self.assertStartsWith(port_line, prefix)
107
159
        port = int(port_line[len(prefix):])
108
 
        return process,'bzr://localhost:%d/' % port
 
160
        url = 'bzr://localhost:%d/' % port
 
161
        self.permit_url(url)
 
162
        return process, url
 
163
    
 
164
    def test_bzr_serve_quiet(self):
 
165
        self.make_branch('.')
 
166
        args = ['--port', 'localhost:0', '--quiet']
 
167
        out, err = self.run_bzr_serve_then_func(args, retcode=3)
 
168
        self.assertEqual('', out)
 
169
        self.assertEqual('', err)
109
170
 
110
171
    def test_bzr_serve_inet_readonly(self):
111
172
        """bzr server should provide a read only filesystem by default."""
154
215
        self.make_read_requests(branch)
155
216
        self.assertServerFinishesCleanly(process)
156
217
 
157
 
    def test_bzr_connect_to_bzr_ssh(self):
158
 
        """User acceptance that get_transport of a bzr+ssh:// behaves correctly.
159
 
 
160
 
        bzr+ssh:// should cause bzr to run a remote bzr smart server over SSH.
161
 
        """
162
 
        try:
163
 
            from bzrlib.transport.sftp import SFTPServer
164
 
        except ParamikoNotPresent:
165
 
            raise TestSkipped('Paramiko not installed')
166
 
        from bzrlib.tests.stub_sftp import StubServer
167
 
 
168
 
        # Make a branch
169
 
        self.make_branch('a_branch')
170
 
 
171
 
        # Start an SSH server
172
 
        self.command_executed = []
173
 
        # XXX: This is horrible -- we define a really dumb SSH server that
174
 
        # executes commands, and manage the hooking up of stdin/out/err to the
175
 
        # SSH channel ourselves.  Surely this has already been implemented
176
 
        # elsewhere?
177
 
        class StubSSHServer(StubServer):
178
 
 
179
 
            test = self
180
 
 
181
 
            def check_channel_exec_request(self, channel, command):
182
 
                self.test.command_executed.append(command)
183
 
                proc = subprocess.Popen(
184
 
                    command, shell=True, stdin=subprocess.PIPE,
185
 
                    stdout=subprocess.PIPE, stderr=subprocess.PIPE)
186
 
 
187
 
                # XXX: horribly inefficient, not to mention ugly.
188
 
                # Start a thread for each of stdin/out/err, and relay bytes from
189
 
                # the subprocess to channel and vice versa.
190
 
                def ferry_bytes(read, write, close):
191
 
                    while True:
192
 
                        bytes = read(1)
193
 
                        if bytes == '':
194
 
                            close()
195
 
                            break
196
 
                        write(bytes)
197
 
 
198
 
                file_functions = [
199
 
                    (channel.recv, proc.stdin.write, proc.stdin.close),
200
 
                    (proc.stdout.read, channel.sendall, channel.close),
201
 
                    (proc.stderr.read, channel.sendall_stderr, channel.close)]
202
 
                for read, write, close in file_functions:
203
 
                    t = threading.Thread(
204
 
                        target=ferry_bytes, args=(read, write, close))
205
 
                    t.start()
206
 
 
207
 
                return True
208
 
 
209
 
        ssh_server = SFTPServer(StubSSHServer)
210
 
        # XXX: We *don't* want to override the default SSH vendor, so we set
211
 
        # _vendor to what _get_ssh_vendor returns.
212
 
        ssh_server.setUp()
213
 
        self.addCleanup(ssh_server.tearDown)
214
 
        port = ssh_server._listener.port
215
 
 
216
 
        # Access the branch via a bzr+ssh URL.  The BZR_REMOTE_PATH environment
217
 
        # variable is used to tell bzr what command to run on the remote end.
218
 
        path_to_branch = osutils.abspath('a_branch')
219
 
 
220
 
        orig_bzr_remote_path = os.environ.get('BZR_REMOTE_PATH')
221
 
        bzr_remote_path = self.get_bzr_path()
222
 
        if sys.platform == 'win32':
223
 
            bzr_remote_path = sys.executable + ' ' + self.get_bzr_path()
224
 
        os.environ['BZR_REMOTE_PATH'] = bzr_remote_path
225
 
        try:
226
 
            if sys.platform == 'win32':
227
 
                path_to_branch = os.path.splitdrive(path_to_branch)[1]
228
 
            branch = Branch.open(
229
 
                'bzr+ssh://fred:secret@localhost:%d%s' % (port, path_to_branch))
230
 
            self.make_read_requests(branch)
231
 
            # Check we can perform write operations
232
 
            branch.bzrdir.root_transport.mkdir('foo')
233
 
        finally:
234
 
            # Restore the BZR_REMOTE_PATH environment variable back to its
235
 
            # original state.
236
 
            if orig_bzr_remote_path is None:
237
 
                del os.environ['BZR_REMOTE_PATH']
238
 
            else:
239
 
                os.environ['BZR_REMOTE_PATH'] = orig_bzr_remote_path
240
 
 
241
 
        self.assertEqual(
242
 
            ['%s serve --inet --directory=/ --allow-writes'
243
 
             % bzr_remote_path],
244
 
            self.command_executed)
245
 
 
246
 
 
247
 
class TestCmdServeChrooting(TestCaseWithTransport):
 
218
 
 
219
class TestCmdServeChrooting(TestBzrServeBase):
248
220
 
249
221
    def test_serve_tcp(self):
250
222
        """'bzr serve' wraps the given --directory in a ChrootServer.
256
228
        t = self.get_transport()
257
229
        t.mkdir('server-root')
258
230
        self.run_bzr_serve_then_func(
259
 
            ['--port', '0', '--directory', t.local_abspath('server-root'),
 
231
            ['--port', '127.0.0.1:0',
 
232
             '--directory', t.local_abspath('server-root'),
260
233
             '--allow-writes'],
261
 
            self.when_server_started)
 
234
            func=self.when_server_started)
262
235
        # The when_server_started method issued a find_repositoryV3 that should
263
236
        # fail with 'norepository' because there are no repositories inside the
264
237
        # --directory.
265
238
        self.assertEqual(('norepository',), self.client_resp)
266
 
        
267
 
    def run_bzr_serve_then_func(self, serve_args, func, *func_args,
268
 
            **func_kwargs):
269
 
        """Run 'bzr serve', and run the given func in a thread once the server
270
 
        has started.
271
 
        
272
 
        When 'func' terminates, the server will be terminated too.
273
 
        """
274
 
        # install hook
275
 
        def on_server_start(backing_urls, tcp_server):
276
 
            t = threading.Thread(
277
 
                target=on_server_start_thread, args=(tcp_server,))
278
 
            t.start()
279
 
        def on_server_start_thread(tcp_server):
280
 
            try:
281
 
                # Run func
282
 
                self.tcp_server = tcp_server
283
 
                try:
284
 
                    func(*func_args, **func_kwargs)
285
 
                except Exception, e:
286
 
                    # Log errors to make some test failures a little less
287
 
                    # mysterious.
288
 
                    mutter('func broke: %r', e)
289
 
            finally:
290
 
                # Then stop the server
291
 
                mutter('interrupting...')
292
 
                thread.interrupt_main()
293
 
        SmartTCPServer.hooks.install_named_hook(
294
 
            'server_started_ex', on_server_start,
295
 
            'run_bzr_serve_then_func hook')
296
 
        # start a TCP server
297
 
        try:
298
 
            self.run_bzr(['serve'] + list(serve_args))
299
 
        except KeyboardInterrupt:
300
 
            pass
301
239
 
302
240
    def when_server_started(self):
303
241
        # Connect to the TCP server and issue some requests and see what comes
316
254
        client_medium.disconnect()
317
255
 
318
256
 
 
257
class TestUserdirExpansion(TestCaseWithMemoryTransport):
 
258
 
 
259
    def fake_expanduser(self, path):
 
260
        """A simple, environment-independent, function for the duration of this
 
261
        test.
 
262
 
 
263
        Paths starting with a path segment of '~user' will expand to start with
 
264
        '/home/user/'.  Every other path will be unchanged.
 
265
        """
 
266
        if path.split('/', 1)[0] == '~user':
 
267
            return '/home/user' + path[len('~user'):]
 
268
        return path
 
269
 
 
270
    def make_test_server(self, base_path='/'):
 
271
        """Make and setUp a BzrServerFactory, backed by a memory transport, and
 
272
        creat '/home/user' in that transport.
 
273
        """
 
274
        bzr_server = BzrServerFactory(
 
275
            self.fake_expanduser, lambda t: base_path)
 
276
        mem_transport = self.get_transport()
 
277
        mem_transport.mkdir_multi(['home', 'home/user'])
 
278
        bzr_server.set_up(mem_transport, None, None, inet=True)
 
279
        self.addCleanup(bzr_server.tear_down)
 
280
        return bzr_server
 
281
 
 
282
    def test_bzr_serve_expands_userdir(self):
 
283
        bzr_server = self.make_test_server()
 
284
        self.assertTrue(bzr_server.smart_server.backing_transport.has('~user'))
 
285
 
 
286
    def test_bzr_serve_does_not_expand_userdir_outside_base(self):
 
287
        bzr_server = self.make_test_server('/foo')
 
288
        self.assertFalse(bzr_server.smart_server.backing_transport.has('~user'))
 
289
 
 
290
    def test_get_base_path(self):
 
291
        """cmd_serve will turn the --directory option into a LocalTransport
 
292
        (optionally decorated with 'readonly+').  BzrServerFactory can
 
293
        determine the original --directory from that transport.
 
294
        """
 
295
        # URLs always include the trailing slash, and get_base_path returns it
 
296
        base_dir = osutils.abspath('/a/b/c') + '/'
 
297
        base_url = urlutils.local_path_to_url(base_dir) + '/'
 
298
        # Define a fake 'protocol' to capture the transport that cmd_serve
 
299
        # passes to serve_bzr.
 
300
        def capture_transport(transport, host, port, inet):
 
301
            self.bzr_serve_transport = transport
 
302
        cmd = builtins.cmd_serve()
 
303
        # Read-only
 
304
        cmd.run(directory=base_dir, protocol=capture_transport)
 
305
        server_maker = BzrServerFactory()
 
306
        self.assertEqual(
 
307
            'readonly+%s' % base_url, self.bzr_serve_transport.base)
 
308
        self.assertEqual(
 
309
            base_dir, server_maker.get_base_path(self.bzr_serve_transport))
 
310
        # Read-write
 
311
        cmd.run(directory=base_dir, protocol=capture_transport,
 
312
            allow_writes=True)
 
313
        server_maker = BzrServerFactory()
 
314
        self.assertEqual(base_url, self.bzr_serve_transport.base)
 
315
        self.assertEqual(base_dir,
 
316
            server_maker.get_base_path(self.bzr_serve_transport))
319
317