28
27
from bzrlib import (
33
30
revision as _mod_revision,
37
33
from bzrlib.branch import Branch
38
34
from bzrlib.bzrdir import BzrDir
35
from bzrlib.errors import ParamikoNotPresent
39
36
from bzrlib.smart import client, medium
40
from bzrlib.smart.server import BzrServerFactory, SmartTCPServer
41
from bzrlib.tests import (
42
TestCaseWithMemoryTransport,
43
TestCaseWithTransport,
37
from bzrlib.smart.server import SmartTCPServer
38
from bzrlib.tests import TestCaseWithTransport, TestSkipped
46
39
from bzrlib.trace import mutter
47
from bzrlib.transport import remote
50
class TestBzrServeBase(TestCaseWithTransport):
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
57
When 'func' terminates, the server will be terminated too.
59
Returns stdout and stderr.
62
def on_server_start(backing_urls, tcp_server):
64
target=on_server_start_thread, args=(tcp_server,))
66
def on_server_start_thread(tcp_server):
69
self.tcp_server = tcp_server
72
func(*func_args, **func_kwargs)
74
# Log errors to make some test failures a little less
76
mutter('func broke: %r', e)
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')
86
out, err = self.run_bzr(['serve'] + list(serve_args))
87
except KeyboardInterrupt, e:
92
class TestBzrServe(TestBzrServeBase):
95
super(TestBzrServe, self).setUp()
96
self.disable_missing_extensions_warning()
40
from bzrlib.transport import get_transport, remote
43
class TestBzrServe(TestCaseWithTransport):
98
45
def assertInetServerShutsdownCleanly(self, process):
99
46
"""Shutdown the server process looking for errors."""
132
79
finish_bzr_subprocess, a client for the server, and a transport.
134
81
# Serve from the current directory
135
args = ['serve', '--inet']
136
args.extend(extra_options)
137
process = self.start_bzr_subprocess(args)
82
process = self.start_bzr_subprocess(['serve', '--inet'])
139
84
# Connect to the server
140
85
# We use this url because while this is no valid URL to connect to this
141
86
# server instance, the transport needs a URL.
142
87
url = 'bzr://localhost/'
144
88
client_medium = medium.SmartSimplePipesClientMedium(
145
89
process.stdout, process.stdin, url)
146
90
transport = remote.RemoteTransport(url, medium=client_medium)
161
105
prefix = 'listening on port: '
162
106
self.assertStartsWith(port_line, prefix)
163
107
port = int(port_line[len(prefix):])
164
url = 'bzr://localhost:%d/' % port
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)
108
return process,'bzr://localhost:%d/' % port
175
110
def test_bzr_serve_inet_readonly(self):
176
111
"""bzr server should provide a read only filesystem by default."""
185
120
process, transport = self.start_server_inet(['--allow-writes'])
187
# We get a working branch, and can create a directory
122
# We get a working branch
188
123
branch = BzrDir.open_from_transport(transport).open_branch()
189
124
self.make_read_requests(branch)
190
transport.mkdir('adir')
191
125
self.assertInetServerShutsdownCleanly(process)
193
127
def test_bzr_serve_port_readonly(self):
194
128
"""bzr server should provide a read only filesystem by default."""
195
129
process, url = self.start_server_port()
196
t = transport.get_transport(url)
197
self.assertRaises(errors.TransportNotPossible, t.mkdir, 'adir')
130
transport = get_transport(url)
131
self.assertRaises(errors.TransportNotPossible, transport.mkdir, 'adir')
198
132
self.assertServerFinishesCleanly(process)
200
134
def test_bzr_serve_port_readwrite(self):
220
154
self.make_read_requests(branch)
221
155
self.assertServerFinishesCleanly(process)
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')
236
self.assertContainsRe(content, r'hpss request: \[[0-9-]+\]')
239
class TestCmdServeChrooting(TestBzrServeBase):
157
def test_bzr_connect_to_bzr_ssh(self):
158
"""User acceptance that get_transport of a bzr+ssh:// behaves correctly.
160
bzr+ssh:// should cause bzr to run a remote bzr smart server over SSH.
163
from bzrlib.transport.sftp import SFTPServer
164
except ParamikoNotPresent:
165
raise TestSkipped('Paramiko not installed')
166
from bzrlib.tests.stub_sftp import StubServer
169
self.make_branch('a_branch')
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
177
class StubSSHServer(StubServer):
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)
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):
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))
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.
213
self.addCleanup(ssh_server.tearDown)
214
port = ssh_server._listener.port
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')
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
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')
234
# Restore the BZR_REMOTE_PATH environment variable back to its
236
if orig_bzr_remote_path is None:
237
del os.environ['BZR_REMOTE_PATH']
239
os.environ['BZR_REMOTE_PATH'] = orig_bzr_remote_path
242
['%s serve --inet --directory=/ --allow-writes'
244
self.command_executed)
247
class TestCmdServeChrooting(TestCaseWithTransport):
241
249
def test_serve_tcp(self):
242
250
"""'bzr serve' wraps the given --directory in a ChrootServer.
248
256
t = self.get_transport()
249
257
t.mkdir('server-root')
250
258
self.run_bzr_serve_then_func(
251
['--port', '127.0.0.1:0',
252
'--directory', t.local_abspath('server-root'),
259
['--port', '0', '--directory', t.local_abspath('server-root'),
253
260
'--allow-writes'],
254
func=self.when_server_started)
261
self.when_server_started)
255
262
# The when_server_started method issued a find_repositoryV3 that should
256
263
# fail with 'norepository' because there are no repositories inside the
258
265
self.assertEqual(('norepository',), self.client_resp)
267
def run_bzr_serve_then_func(self, serve_args, func, *func_args,
269
"""Run 'bzr serve', and run the given func in a thread once the server
272
When 'func' terminates, the server will be terminated too.
275
def on_server_start(backing_urls, tcp_server):
276
t = threading.Thread(
277
target=on_server_start_thread, args=(tcp_server,))
279
def on_server_start_thread(tcp_server):
282
self.tcp_server = tcp_server
284
func(*func_args, **func_kwargs)
286
# Log errors to make some test failures a little less
288
mutter('func broke: %r', e)
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')
298
self.run_bzr(['serve'] + list(serve_args))
299
except KeyboardInterrupt:
260
302
def when_server_started(self):
261
303
# Connect to the TCP server and issue some requests and see what comes
274
316
client_medium.disconnect()
277
class TestUserdirExpansion(TestCaseWithMemoryTransport):
279
def fake_expanduser(self, path):
280
"""A simple, environment-independent, function for the duration of this
283
Paths starting with a path segment of '~user' will expand to start with
284
'/home/user/'. Every other path will be unchanged.
286
if path.split('/', 1)[0] == '~user':
287
return '/home/user' + path[len('~user'):]
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.
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)
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'))
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'))
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.
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()
324
cmd.run(directory=base_dir, protocol=capture_transport)
325
server_maker = BzrServerFactory()
327
'readonly+%s' % base_url, self.bzr_serve_transport.base)
329
base_dir, server_maker.get_base_path(self.bzr_serve_transport))
331
cmd.run(directory=base_dir, protocol=capture_transport,
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))
added
removed
bzrlib/tests/blackbox/test_serve.py
