/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: Robert Collins
  • Date: 2007-03-06 12:28:18 UTC
  • mto: (2321.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 2322.
  • Revision ID: robertc@robertcollins.net-20070306122818-xk0lc3l01ecl6vbc
Get merge_nested finally working: change nested tree iterators to take file_ids, and ensure the right branch is connected to in the merge logic. May not be suitable for shared repositories yet.

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