← Back to branch summary

~greatmay12/+junk/test1

« back to all changes in this revision

Viewing changes to build/lib.linux-x86_64-2.6/bzrlib/tests/blackbox/test_serve.py

  • Committer: thitipong at ndrsolution
  • Date: 2011-11-14 06:31:02 UTC
  • Revision ID: thitipong@ndrsolution.com-20111114063102-9obte3yfi2azku7d
ndr redirect version

Show diffs side-by-side

added added

removed removed

Lines of Context:
build/lib.linux-x86_64-2.6/bzrlib/tests/blackbox/test_serve.py
 
1
# Copyright (C) 2006-2010 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
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
 
16
 
 
17
 
 
18
"""Tests of the bzr serve command."""
 
19
 
 
20
import os
 
21
import os.path
 
22
import signal
 
23
import subprocess
 
24
import sys
 
25
import thread
 
26
import threading
 
27
 
 
28
from bzrlib import (
 
29
    builtins,
 
30
    debug,
 
31
    errors,
 
32
    osutils,
 
33
    revision as _mod_revision,
 
34
    transport,
 
35
    urlutils,
 
36
    )
 
37
from bzrlib.branch import Branch
 
38
from bzrlib.bzrdir import BzrDir
 
39
from bzrlib.smart import client, medium
 
40
from bzrlib.smart.server import BzrServerFactory, SmartTCPServer
 
41
from bzrlib.tests import (
 
42
    TestCaseWithMemoryTransport,
 
43
    TestCaseWithTransport,
 
44
    TestSkipped,
 
45
    )
 
46
from bzrlib.trace import mutter
 
47
from bzrlib.transport import remote
 
48
 
 
49
 
 
50
class TestBzrServeBase(TestCaseWithTransport):
 
51
 
 
52
    def run_bzr_serve_then_func(self, serve_args, retcode=0, func=None,
 
53
                                *func_args, **func_kwargs):
 
54
        """Run 'bzr serve', and run the given func in a thread once the server
 
55
        has started.
 
56
        
 
57
        When 'func' terminates, the server will be terminated too.
 
58
        
 
59
        Returns stdout and stderr.
 
60
        """
 
61
        # install hook
 
62
        def on_server_start(backing_urls, tcp_server):
 
63
            t = threading.Thread(
 
64
                target=on_server_start_thread, args=(tcp_server,))
 
65
            t.start()
 
66
        def on_server_start_thread(tcp_server):
 
67
            try:
 
68
                # Run func if set
 
69
                self.tcp_server = tcp_server
 
70
                if not func is None:
 
71
                    try:
 
72
                        func(*func_args, **func_kwargs)
 
73
                    except Exception, e:
 
74
                        # Log errors to make some test failures a little less
 
75
                        # mysterious.
 
76
                        mutter('func broke: %r', e)
 
77
            finally:
 
78
                # Then stop the server
 
79
                mutter('interrupting...')
 
80
                thread.interrupt_main()
 
81
        SmartTCPServer.hooks.install_named_hook(
 
82
            'server_started_ex', on_server_start,
 
83
            'run_bzr_serve_then_func hook')
 
84
        # start a TCP server
 
85
        try:
 
86
            out, err = self.run_bzr(['serve'] + list(serve_args))
 
87
        except KeyboardInterrupt, e:
 
88
            out, err = e.args
 
89
        return out, err
 
90
 
 
91
 
 
92
class TestBzrServe(TestBzrServeBase):
 
93
 
 
94
    def setUp(self):
 
95
        super(TestBzrServe, self).setUp()
 
96
        self.disable_missing_extensions_warning()
 
97
 
 
98
    def assertInetServerShutsdownCleanly(self, process):
 
99
        """Shutdown the server process looking for errors."""
 
100
        # Shutdown the server: the server should shut down when it cannot read
 
101
        # from stdin anymore.
 
102
        process.stdin.close()
 
103
        # Hide stdin from the subprocess module, so it won't fail to close it.
 
104
        process.stdin = None
 
105
        result = self.finish_bzr_subprocess(process)
 
106
        self.assertEqual('', result[0])
 
107
        self.assertEqual('', result[1])
 
108
 
 
109
    def assertServerFinishesCleanly(self, process):
 
110
        """Shutdown the bzr serve instance process looking for errors."""
 
111
        # Shutdown the server
 
112
        result = self.finish_bzr_subprocess(process, retcode=3,
 
113
                                            send_signal=signal.SIGINT)
 
114
        self.assertEqual('', result[0])
 
115
        self.assertEqual('bzr: interrupted\n', result[1])
 
116
 
 
117
    def make_read_requests(self, branch):
 
118
        """Do some read only requests."""
 
119
        branch.lock_read()
 
120
        try:
 
121
            branch.repository.all_revision_ids()
 
122
            self.assertEqual(_mod_revision.NULL_REVISION,
 
123
                             _mod_revision.ensure_null(branch.last_revision()))
 
124
        finally:
 
125
            branch.unlock()
 
126
 
 
127
    def start_server_inet(self, extra_options=()):
 
128
        """Start a bzr server subprocess using the --inet option.
 
129
 
 
130
        :param extra_options: extra options to give the server.
 
131
        :return: a tuple with the bzr process handle for passing to
 
132
            finish_bzr_subprocess, a client for the server, and a transport.
 
133
        """
 
134
        # Serve from the current directory
 
135
        args = ['serve', '--inet']
 
136
        args.extend(extra_options)
 
137
        process = self.start_bzr_subprocess(args)
 
138
 
 
139
        # Connect to the server
 
140
        # We use this url because while this is no valid URL to connect to this
 
141
        # server instance, the transport needs a URL.
 
142
        url = 'bzr://localhost/'
 
143
        self.permit_url(url)
 
144
        client_medium = medium.SmartSimplePipesClientMedium(
 
145
            process.stdout, process.stdin, url)
 
146
        transport = remote.RemoteTransport(url, medium=client_medium)
 
147
        return process, transport
 
148
 
 
149
    def start_server_port(self, extra_options=()):
 
150
        """Start a bzr server subprocess.
 
151
 
 
152
        :param extra_options: extra options to give the server.
 
153
        :return: a tuple with the bzr process handle for passing to
 
154
            finish_bzr_subprocess, and the base url for the server.
 
155
        """
 
156
        # Serve from the current directory
 
157
        args = ['serve', '--port', 'localhost:0']
 
158
        args.extend(extra_options)
 
159
        process = self.start_bzr_subprocess(args, skip_if_plan_to_signal=True)
 
160
        port_line = process.stderr.readline()
 
161
        prefix = 'listening on port: '
 
162
        self.assertStartsWith(port_line, prefix)
 
163
        port = int(port_line[len(prefix):])
 
164
        url = 'bzr://localhost:%d/' % port
 
165
        self.permit_url(url)
 
166
        return process, url
 
167
    
 
168
    def test_bzr_serve_quiet(self):
 
169
        self.make_branch('.')
 
170
        args = ['--port', 'localhost:0', '--quiet']
 
171
        out, err = self.run_bzr_serve_then_func(args, retcode=3)
 
172
        self.assertEqual('', out)
 
173
        self.assertEqual('', err)
 
174
 
 
175
    def test_bzr_serve_inet_readonly(self):
 
176
        """bzr server should provide a read only filesystem by default."""
 
177
        process, transport = self.start_server_inet()
 
178
        self.assertRaises(errors.TransportNotPossible, transport.mkdir, 'adir')
 
179
        self.assertInetServerShutsdownCleanly(process)
 
180
 
 
181
    def test_bzr_serve_inet_readwrite(self):
 
182
        # Make a branch
 
183
        self.make_branch('.')
 
184
 
 
185
        process, transport = self.start_server_inet(['--allow-writes'])
 
186
 
 
187
        # We get a working branch, and can create a directory
 
188
        branch = BzrDir.open_from_transport(transport).open_branch()
 
189
        self.make_read_requests(branch)
 
190
        transport.mkdir('adir')
 
191
        self.assertInetServerShutsdownCleanly(process)
 
192
 
 
193
    def test_bzr_serve_port_readonly(self):
 
194
        """bzr server should provide a read only filesystem by default."""
 
195
        process, url = self.start_server_port()
 
196
        t = transport.get_transport(url)
 
197
        self.assertRaises(errors.TransportNotPossible, t.mkdir, 'adir')
 
198
        self.assertServerFinishesCleanly(process)
 
199
 
 
200
    def test_bzr_serve_port_readwrite(self):
 
201
        # Make a branch
 
202
        self.make_branch('.')
 
203
 
 
204
        process, url = self.start_server_port(['--allow-writes'])
 
205
 
 
206
        # Connect to the server
 
207
        branch = Branch.open(url)
 
208
        self.make_read_requests(branch)
 
209
        self.assertServerFinishesCleanly(process)
 
210
 
 
211
    def test_bzr_serve_supports_protocol(self):
 
212
        # Make a branch
 
213
        self.make_branch('.')
 
214
 
 
215
        process, url = self.start_server_port(['--allow-writes',
 
216
                                               '--protocol=bzr'])
 
217
 
 
218
        # Connect to the server
 
219
        branch = Branch.open(url)
 
220
        self.make_read_requests(branch)
 
221
        self.assertServerFinishesCleanly(process)
 
222
 
 
223
    def test_bzr_serve_dhpss(self):
 
224
        # This is a smoke test that the server doesn't crash when run with
 
225
        # -Dhpss, and does drop some hpss logging to the file.
 
226
        self.make_branch('.')
 
227
        log_fname = os.getcwd() + '/server.log'
 
228
        self._captureVar('BZR_LOG', log_fname)
 
229
        process, transport = self.start_server_inet(['-Dhpss'])
 
230
        branch = BzrDir.open_from_transport(transport).open_branch()
 
231
        self.make_read_requests(branch)
 
232
        self.assertInetServerShutsdownCleanly(process)
 
233
        f = open(log_fname, 'rb')
 
234
        content = f.read()
 
235
        f.close()
 
236
        self.assertContainsRe(content, r'hpss request: \[[0-9-]+\]')
 
237
 
 
238
 
 
239
class TestCmdServeChrooting(TestBzrServeBase):
 
240
 
 
241
    def test_serve_tcp(self):
 
242
        """'bzr serve' wraps the given --directory in a ChrootServer.
 
243
 
 
244
        So requests that search up through the parent directories (like
 
245
        find_repositoryV3) will give "not found" responses, rather than
 
246
        InvalidURLJoin or jail break errors.
 
247
        """
 
248
        t = self.get_transport()
 
249
        t.mkdir('server-root')
 
250
        self.run_bzr_serve_then_func(
 
251
            ['--port', '127.0.0.1:0',
 
252
             '--directory', t.local_abspath('server-root'),
 
253
             '--allow-writes'],
 
254
            func=self.when_server_started)
 
255
        # The when_server_started method issued a find_repositoryV3 that should
 
256
        # fail with 'norepository' because there are no repositories inside the
 
257
        # --directory.
 
258
        self.assertEqual(('norepository',), self.client_resp)
 
259
 
 
260
    def when_server_started(self):
 
261
        # Connect to the TCP server and issue some requests and see what comes
 
262
        # back.
 
263
        client_medium = medium.SmartTCPClientMedium(
 
264
            '127.0.0.1', self.tcp_server.port,
 
265
            'bzr://localhost:%d/' % (self.tcp_server.port,))
 
266
        smart_client = client._SmartClient(client_medium)
 
267
        resp = smart_client.call('mkdir', 'foo', '')
 
268
        resp = smart_client.call('BzrDirFormat.initialize', 'foo/')
 
269
        try:
 
270
            resp = smart_client.call('BzrDir.find_repositoryV3', 'foo/')
 
271
        except errors.ErrorFromSmartServer, e:
 
272
            resp = e.error_tuple
 
273
        self.client_resp = resp
 
274
        client_medium.disconnect()
 
275
 
 
276
 
 
277
class TestUserdirExpansion(TestCaseWithMemoryTransport):
 
278
 
 
279
    def fake_expanduser(self, path):
 
280
        """A simple, environment-independent, function for the duration of this
 
281
        test.
 
282
 
 
283
        Paths starting with a path segment of '~user' will expand to start with
 
284
        '/home/user/'.  Every other path will be unchanged.
 
285
        """
 
286
        if path.split('/', 1)[0] == '~user':
 
287
            return '/home/user' + path[len('~user'):]
 
288
        return path
 
289
 
 
290
    def make_test_server(self, base_path='/'):
 
291
        """Make and start a BzrServerFactory, backed by a memory transport, and
 
292
        creat '/home/user' in that transport.
 
293
        """
 
294
        bzr_server = BzrServerFactory(
 
295
            self.fake_expanduser, lambda t: base_path)
 
296
        mem_transport = self.get_transport()
 
297
        mem_transport.mkdir_multi(['home', 'home/user'])
 
298
        bzr_server.set_up(mem_transport, None, None, inet=True)
 
299
        self.addCleanup(bzr_server.tear_down)
 
300
        return bzr_server
 
301
 
 
302
    def test_bzr_serve_expands_userdir(self):
 
303
        bzr_server = self.make_test_server()
 
304
        self.assertTrue(bzr_server.smart_server.backing_transport.has('~user'))
 
305
 
 
306
    def test_bzr_serve_does_not_expand_userdir_outside_base(self):
 
307
        bzr_server = self.make_test_server('/foo')
 
308
        self.assertFalse(bzr_server.smart_server.backing_transport.has('~user'))
 
309
 
 
310
    def test_get_base_path(self):
 
311
        """cmd_serve will turn the --directory option into a LocalTransport
 
312
        (optionally decorated with 'readonly+').  BzrServerFactory can
 
313
        determine the original --directory from that transport.
 
314
        """
 
315
        # URLs always include the trailing slash, and get_base_path returns it
 
316
        base_dir = osutils.abspath('/a/b/c') + '/'
 
317
        base_url = urlutils.local_path_to_url(base_dir) + '/'
 
318
        # Define a fake 'protocol' to capture the transport that cmd_serve
 
319
        # passes to serve_bzr.
 
320
        def capture_transport(transport, host, port, inet):
 
321
            self.bzr_serve_transport = transport
 
322
        cmd = builtins.cmd_serve()
 
323
        # Read-only
 
324
        cmd.run(directory=base_dir, protocol=capture_transport)
 
325
        server_maker = BzrServerFactory()
 
326
        self.assertEqual(
 
327
            'readonly+%s' % base_url, self.bzr_serve_transport.base)
 
328
        self.assertEqual(
 
329
            base_dir, server_maker.get_base_path(self.bzr_serve_transport))
 
330
        # Read-write
 
331
        cmd.run(directory=base_dir, protocol=capture_transport,
 
332
            allow_writes=True)
 
333
        server_maker = BzrServerFactory()
 
334
        self.assertEqual(base_url, self.bzr_serve_transport.base)
 
335
        self.assertEqual(base_dir,
 
336
            server_maker.get_base_path(self.bzr_serve_transport))
 
337