27
27
from bzrlib import (
30
32
revision as _mod_revision,
33
37
from bzrlib.branch import Branch
34
38
from bzrlib.bzrdir import BzrDir
35
from bzrlib.errors import ParamikoNotPresent
36
39
from bzrlib.smart import client, medium
37
from bzrlib.smart.server import SmartTCPServer
38
from bzrlib.tests import TestCaseWithTransport, TestSkipped
39
from bzrlib.trace import mutter
40
from bzrlib.transport import get_transport, remote
43
class TestBzrServe(TestCaseWithTransport):
40
from bzrlib.smart.server import (
44
from bzrlib.tests import (
45
TestCaseWithMemoryTransport,
46
TestCaseWithTransport,
48
from bzrlib.transport import remote
51
class TestBzrServeBase(TestCaseWithTransport):
53
def run_bzr_serve_then_func(self, serve_args, retcode=0, func=None,
54
*func_args, **func_kwargs):
55
"""Run 'bzr serve', and run the given func in a thread once the server
58
When 'func' terminates, the server will be terminated too.
60
Returns stdout and stderr.
62
def on_server_start_thread(tcp_server):
63
"""This runs concurrently with the server thread.
65
The server is interrupted as soon as ``func`` finishes, even if an
66
exception is encountered.
70
self.tcp_server = tcp_server
73
func(*func_args, **func_kwargs)
75
# Log errors to make some test failures a little less
77
trace.mutter('func broke: %r', e)
79
# Then stop the server
80
trace.mutter('interrupting...')
81
thread.interrupt_main()
82
# When the hook is fired, it just starts ``on_server_start_thread`` and
84
def on_server_start(backing_urls, tcp_server):
86
target=on_server_start_thread, args=(tcp_server,))
89
SmartTCPServer.hooks.install_named_hook(
90
'server_started_ex', on_server_start,
91
'run_bzr_serve_then_func hook')
92
# It seesm thread.interrupt_main() will not raise KeyboardInterrupt
93
# until after socket.accept returns. So we set the timeout low to make
95
self.overrideAttr(SmartTCPServer, '_ACCEPT_TIMEOUT', 0.1)
98
out, err = self.run_bzr(['serve'] + list(serve_args),
100
except KeyboardInterrupt, e:
105
class TestBzrServe(TestBzrServeBase):
108
super(TestBzrServe, self).setUp()
109
self.disable_missing_extensions_warning()
111
def test_server_exception_with_hook(self):
112
"""Catch exception from the server in the server_exception hook.
114
We use ``run_bzr_serve_then_func`` without a ``func`` so the server
115
will receive a KeyboardInterrupt exception we want to catch.
118
if exception[0] is KeyboardInterrupt:
119
sys.stderr.write('catching KeyboardInterrupt\n')
123
SmartTCPServer.hooks.install_named_hook(
124
'server_exception', hook,
125
'test_server_except_hook hook')
126
args = ['--port', 'localhost:0', '--quiet']
127
out, err = self.run_bzr_serve_then_func(args, retcode=0)
128
self.assertEqual('catching KeyboardInterrupt\n', err)
130
def test_server_exception_no_hook(self):
131
"""test exception without hook returns error"""
133
out, err = self.run_bzr_serve_then_func(args, retcode=3)
45
135
def assertInetServerShutsdownCleanly(self, process):
46
136
"""Shutdown the server process looking for errors."""
154
257
self.make_read_requests(branch)
155
258
self.assertServerFinishesCleanly(process)
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):
260
def test_bzr_serve_dhpss(self):
261
# This is a smoke test that the server doesn't crash when run with
262
# -Dhpss, and does drop some hpss logging to the file.
263
self.make_branch('.')
264
log_fname = os.getcwd() + '/server.log'
265
self.overrideEnv('BZR_LOG', log_fname)
266
process, transport = self.start_server_inet(['-Dhpss'])
267
branch = BzrDir.open_from_transport(transport).open_branch()
268
self.make_read_requests(branch)
269
self.assertInetServerShutsdownCleanly(process)
270
f = open(log_fname, 'rb')
273
self.assertContainsRe(content, r'hpss request: \[[0-9-]+\]')
275
def test_bzr_serve_supports_configurable_timeout(self):
276
gs = config.GlobalStack()
277
gs.set('serve.client_timeout', 0.2)
278
process, url = self.start_server_port()
279
self.build_tree_contents([('a_file', 'contents\n')])
280
# We can connect and issue a request
281
t = transport.get_transport_from_url(url)
282
self.assertEqual('contents\n', t.get_bytes('a_file'))
283
# However, if we just wait for more content from the server, it will
284
# eventually disconnect us.
285
# TODO: Use something like signal.alarm() so that if the server doesn't
286
# properly handle the timeout, we end up failing the test instead
287
# of hanging forever.
288
m = t.get_smart_medium()
290
# Now, we wait for timeout to trigger
291
err = process.stderr.readline()
293
'Connection Timeout: disconnecting client after 0.2 seconds\n',
295
self.assertServerFinishesCleanly(process)
297
def test_bzr_serve_supports_client_timeout(self):
298
process, url = self.start_server_port(['--client-timeout=0.1'])
299
self.build_tree_contents([('a_file', 'contents\n')])
300
# We can connect and issue a request
301
t = transport.get_transport_from_url(url)
302
self.assertEqual('contents\n', t.get_bytes('a_file'))
303
# However, if we just wait for more content from the server, it will
304
# eventually disconnect us.
305
# TODO: Use something like signal.alarm() so that if the server doesn't
306
# properly handle the timeout, we end up failing the test instead
307
# of hanging forever.
308
m = t.get_smart_medium()
310
# Now, we wait for timeout to trigger
311
err = process.stderr.readline()
313
'Connection Timeout: disconnecting client after 0.1 seconds\n',
315
self.assertServerFinishesCleanly(process)
317
def test_bzr_serve_graceful_shutdown(self):
318
big_contents = 'a'*64*1024
319
self.build_tree_contents([('bigfile', big_contents)])
320
process, url = self.start_server_port(['--client-timeout=1.0'])
321
t = transport.get_transport_from_url(url)
322
m = t.get_smart_medium()
323
c = client._SmartClient(m)
324
# Start, but don't finish a response
325
resp, response_handler = c.call_expecting_body('get', 'bigfile')
326
self.assertEqual(('ok',), resp)
327
# Note: process.send_signal is a Python 2.6ism
328
process.send_signal(signal.SIGHUP)
329
# Wait for the server to notice the signal, and then read the actual
330
# body of the response. That way we know that it is waiting for the
332
self.assertEqual('Requested to stop gracefully\n',
333
process.stderr.readline())
334
self.assertEqual('Waiting for 1 client(s) to finish\n',
335
process.stderr.readline())
336
body = response_handler.read_body_bytes()
337
if body != big_contents:
338
self.fail('Failed to properly read the contents of "bigfile"')
339
# Now that our request is finished, the medium should notice it has
341
self.assertEqual('', m.read_bytes(1))
342
# And the server should be stopping
343
self.assertEqual(0, process.wait())
346
class TestCmdServeChrooting(TestBzrServeBase):
249
348
def test_serve_tcp(self):
250
349
"""'bzr serve' wraps the given --directory in a ChrootServer.
256
355
t = self.get_transport()
257
356
t.mkdir('server-root')
258
357
self.run_bzr_serve_then_func(
259
['--port', '0', '--directory', t.local_abspath('server-root'),
358
['--port', '127.0.0.1:0',
359
'--directory', t.local_abspath('server-root'),
260
360
'--allow-writes'],
261
self.when_server_started)
361
func=self.when_server_started)
262
362
# The when_server_started method issued a find_repositoryV3 that should
263
363
# fail with 'norepository' because there are no repositories inside the
265
365
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:
302
367
def when_server_started(self):
303
368
# Connect to the TCP server and issue some requests and see what comes
316
381
client_medium.disconnect()
384
class TestUserdirExpansion(TestCaseWithMemoryTransport):
387
def fake_expanduser(path):
388
"""A simple, environment-independent, function for the duration of this
391
Paths starting with a path segment of '~user' will expand to start with
392
'/home/user/'. Every other path will be unchanged.
394
if path.split('/', 1)[0] == '~user':
395
return '/home/user' + path[len('~user'):]
398
def make_test_server(self, base_path='/'):
399
"""Make and start a BzrServerFactory, backed by a memory transport, and
400
creat '/home/user' in that transport.
402
bzr_server = BzrServerFactory(
403
self.fake_expanduser, lambda t: base_path)
404
mem_transport = self.get_transport()
405
mem_transport.mkdir_multi(['home', 'home/user'])
406
bzr_server.set_up(mem_transport, None, None, inet=True, timeout=4.0)
407
self.addCleanup(bzr_server.tear_down)
410
def test_bzr_serve_expands_userdir(self):
411
bzr_server = self.make_test_server()
412
self.assertTrue(bzr_server.smart_server.backing_transport.has('~user'))
414
def test_bzr_serve_does_not_expand_userdir_outside_base(self):
415
bzr_server = self.make_test_server('/foo')
416
self.assertFalse(bzr_server.smart_server.backing_transport.has('~user'))
418
def test_get_base_path(self):
419
"""cmd_serve will turn the --directory option into a LocalTransport
420
(optionally decorated with 'readonly+'). BzrServerFactory can
421
determine the original --directory from that transport.
423
# URLs always include the trailing slash, and get_base_path returns it
424
base_dir = osutils.abspath('/a/b/c') + '/'
425
base_url = urlutils.local_path_to_url(base_dir) + '/'
426
# Define a fake 'protocol' to capture the transport that cmd_serve
427
# passes to serve_bzr.
428
def capture_transport(transport, host, port, inet, timeout):
429
self.bzr_serve_transport = transport
430
cmd = builtins.cmd_serve()
432
cmd.run(directory=base_dir, protocol=capture_transport)
433
server_maker = BzrServerFactory()
435
'readonly+%s' % base_url, self.bzr_serve_transport.base)
437
base_dir, server_maker.get_base_path(self.bzr_serve_transport))
439
cmd.run(directory=base_dir, protocol=capture_transport,
441
server_maker = BzrServerFactory()
442
self.assertEqual(base_url, self.bzr_serve_transport.base)
443
self.assertEqual(base_dir,
444
server_maker.get_base_path(self.bzr_serve_transport))
added
removed
bzrlib/tests/blackbox/test_serve.py
