/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: 2007-03-14 20:15:52 UTC
  • mto: (2353.4.2 locking)
  • mto: This revision was merged to the branch mainline in revision 2360.
  • Revision ID: john@arbash-meinel.com-20070314201552-bjtfua57456dviep
Update the lock code and test code so that if more than one
lock implementation is available, they will both be tested.

It is quite a bit of overhead, for a case where we are likely to only have 1
real lock implementation per platform, but hey, for now we have 2.

Show diffs side-by-side

added added

removed removed

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