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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
18
"""Tests of the bzr serve command."""
26
26
from bzrlib import (
31
revision as _mod_revision,
30
36
from bzrlib.branch import Branch
31
37
from bzrlib.bzrdir import BzrDir
32
from bzrlib.errors import ParamikoNotPresent
33
from bzrlib.smart import medium
34
from bzrlib.tests import TestCaseWithTransport, TestSkipped
35
from bzrlib.transport import get_transport, remote
38
class TestBzrServe(TestCaseWithTransport):
38
from bzrlib.smart import client, medium
39
from bzrlib.smart.server import (
43
from bzrlib.tests import (
44
TestCaseWithMemoryTransport,
45
TestCaseWithTransport,
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.
61
def on_server_start_thread(tcp_server):
62
"""This runs concurrently with the server thread.
64
The server is interrupted as soon as ``func`` finishes, even if an
65
exception is encountered.
69
self.tcp_server = tcp_server
72
func(*func_args, **func_kwargs)
74
# Log errors to make some test failures a little less
76
trace.mutter('func broke: %r', e)
78
# Then stop the server
79
trace.mutter('interrupting...')
80
thread.interrupt_main()
81
# When the hook is fired, it just starts ``on_server_start_thread`` and
83
def on_server_start(backing_urls, tcp_server):
85
target=on_server_start_thread, args=(tcp_server,))
88
SmartTCPServer.hooks.install_named_hook(
89
'server_started_ex', on_server_start,
90
'run_bzr_serve_then_func hook')
91
# It seesm thread.interrupt_main() will not raise KeyboardInterrupt
92
# until after socket.accept returns. So we set the timeout low to make
94
self.overrideAttr(SmartTCPServer, '_ACCEPT_TIMEOUT', 0.1)
97
out, err = self.run_bzr(['serve'] + list(serve_args),
99
except KeyboardInterrupt, e:
104
class TestBzrServe(TestBzrServeBase):
107
super(TestBzrServe, self).setUp()
108
self.disable_missing_extensions_warning()
110
def test_server_exception_with_hook(self):
111
"""Catch exception from the server in the server_exception hook.
113
We use ``run_bzr_serve_then_func`` without a ``func`` so the server
114
will receive a KeyboardInterrupt exception we want to catch.
117
if exception[0] is KeyboardInterrupt:
118
sys.stderr.write('catching KeyboardInterrupt\n')
122
SmartTCPServer.hooks.install_named_hook(
123
'server_exception', hook,
124
'test_server_except_hook hook')
125
args = ['--port', 'localhost:0', '--quiet']
126
out, err = self.run_bzr_serve_then_func(args, retcode=0)
127
self.assertEqual('catching KeyboardInterrupt\n', err)
129
def test_server_exception_no_hook(self):
130
"""test exception without hook returns error"""
132
out, err = self.run_bzr_serve_then_func(args, retcode=3)
40
134
def assertInetServerShutsdownCleanly(self, process):
41
135
"""Shutdown the server process looking for errors."""
126
242
# Connect to the server
127
243
branch = Branch.open(url)
129
# We get a working branch
130
branch.repository.get_revision_graph()
131
self.assertEqual(None, branch.last_revision())
244
self.make_read_requests(branch)
133
245
self.assertServerFinishesCleanly(process)
135
def test_bzr_connect_to_bzr_ssh(self):
136
"""User acceptance that get_transport of a bzr+ssh:// behaves correctly.
138
bzr+ssh:// should cause bzr to run a remote bzr smart server over SSH.
141
from bzrlib.transport.sftp import SFTPServer
142
except ParamikoNotPresent:
143
raise TestSkipped('Paramiko not installed')
144
from bzrlib.tests.stub_sftp import StubServer
247
def test_bzr_serve_supports_protocol(self):
147
self.make_branch('a_branch')
149
# Start an SSH server
150
self.command_executed = []
151
# XXX: This is horrible -- we define a really dumb SSH server that
152
# executes commands, and manage the hooking up of stdin/out/err to the
153
# SSH channel ourselves. Surely this has already been implemented
155
class StubSSHServer(StubServer):
159
def check_channel_exec_request(self, channel, command):
160
self.test.command_executed.append(command)
161
proc = subprocess.Popen(
162
command, shell=True, stdin=subprocess.PIPE,
163
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
165
# XXX: horribly inefficient, not to mention ugly.
166
# Start a thread for each of stdin/out/err, and relay bytes from
167
# the subprocess to channel and vice versa.
168
def ferry_bytes(read, write, close):
177
(channel.recv, proc.stdin.write, proc.stdin.close),
178
(proc.stdout.read, channel.sendall, channel.close),
179
(proc.stderr.read, channel.sendall_stderr, channel.close)]
180
for read, write, close in file_functions:
181
t = threading.Thread(
182
target=ferry_bytes, args=(read, write, close))
187
ssh_server = SFTPServer(StubSSHServer)
188
# XXX: We *don't* want to override the default SSH vendor, so we set
189
# _vendor to what _get_ssh_vendor returns.
191
self.addCleanup(ssh_server.tearDown)
192
port = ssh_server._listener.port
194
# Access the branch via a bzr+ssh URL. The BZR_REMOTE_PATH environment
195
# variable is used to tell bzr what command to run on the remote end.
196
path_to_branch = osutils.abspath('a_branch')
198
orig_bzr_remote_path = os.environ.get('BZR_REMOTE_PATH')
199
bzr_remote_path = self.get_bzr_path()
200
if sys.platform == 'win32':
201
bzr_remote_path = sys.executable + ' ' + self.get_bzr_path()
202
os.environ['BZR_REMOTE_PATH'] = bzr_remote_path
249
self.make_branch('.')
251
process, url = self.start_server_port(['--allow-writes',
254
# Connect to the server
255
branch = Branch.open(url)
256
self.make_read_requests(branch)
257
self.assertServerFinishesCleanly(process)
259
def test_bzr_serve_dhpss(self):
260
# This is a smoke test that the server doesn't crash when run with
261
# -Dhpss, and does drop some hpss logging to the file.
262
self.make_branch('.')
263
log_fname = os.getcwd() + '/server.log'
264
self.overrideEnv('BZR_LOG', log_fname)
265
process, transport = self.start_server_inet(['-Dhpss'])
266
branch = BzrDir.open_from_transport(transport).open_branch()
267
self.make_read_requests(branch)
268
self.assertInetServerShutsdownCleanly(process)
269
f = open(log_fname, 'rb')
272
self.assertContainsRe(content, r'hpss request: \[[0-9-]+\]')
274
def test_bzr_serve_supports_configurable_timeout(self):
275
gs = config.GlobalStack()
276
gs.set('serve.client_timeout', 0.2)
277
process, url = self.start_server_port()
278
self.build_tree_contents([('a_file', 'contents\n')])
279
# We can connect and issue a request
280
t = transport.get_transport_from_url(url)
281
self.assertEqual('contents\n', t.get_bytes('a_file'))
282
# However, if we just wait for more content from the server, it will
283
# eventually disconnect us.
284
# TODO: Use something like signal.alarm() so that if the server doesn't
285
# properly handle the timeout, we end up failing the test instead
286
# of hanging forever.
287
m = t.get_smart_medium()
289
# Now, we wait for timeout to trigger
290
err = process.stderr.readline()
292
'Connection Timeout: disconnecting client after 0.2 seconds\n',
294
self.assertServerFinishesCleanly(process)
296
def test_bzr_serve_supports_client_timeout(self):
297
process, url = self.start_server_port(['--client-timeout=0.1'])
298
self.build_tree_contents([('a_file', 'contents\n')])
299
# We can connect and issue a request
300
t = transport.get_transport_from_url(url)
301
self.assertEqual('contents\n', t.get_bytes('a_file'))
302
# However, if we just wait for more content from the server, it will
303
# eventually disconnect us.
304
# TODO: Use something like signal.alarm() so that if the server doesn't
305
# properly handle the timeout, we end up failing the test instead
306
# of hanging forever.
307
m = t.get_smart_medium()
309
# Now, we wait for timeout to trigger
310
err = process.stderr.readline()
312
'Connection Timeout: disconnecting client after 0.1 seconds\n',
314
self.assertServerFinishesCleanly(process)
316
def test_bzr_serve_graceful_shutdown(self):
317
big_contents = 'a'*64*1024
318
self.build_tree_contents([('bigfile', big_contents)])
319
process, url = self.start_server_port(['--client-timeout=1.0'])
320
t = transport.get_transport_from_url(url)
321
m = t.get_smart_medium()
322
c = client._SmartClient(m)
323
# Start, but don't finish a response
324
resp, response_handler = c.call_expecting_body('get', 'bigfile')
325
self.assertEqual(('ok',), resp)
326
# Note: process.send_signal is a Python 2.6ism
327
process.send_signal(signal.SIGHUP)
328
# Wait for the server to notice the signal, and then read the actual
329
# body of the response. That way we know that it is waiting for the
331
self.assertEqual('Requested to stop gracefully\n',
332
process.stderr.readline())
333
self.assertEqual('Waiting for 1 client(s) to finish\n',
334
process.stderr.readline())
335
body = response_handler.read_body_bytes()
336
if body != big_contents:
337
self.fail('Failed to properly read the contents of "bigfile"')
338
# Now that our request is finished, the medium should notice it has
340
self.assertEqual('', m.read_bytes(1))
341
# And the server should be stopping
342
self.assertEqual(0, process.wait())
345
class TestCmdServeChrooting(TestBzrServeBase):
347
def test_serve_tcp(self):
348
"""'bzr serve' wraps the given --directory in a ChrootServer.
350
So requests that search up through the parent directories (like
351
find_repositoryV3) will give "not found" responses, rather than
352
InvalidURLJoin or jail break errors.
354
t = self.get_transport()
355
t.mkdir('server-root')
356
self.run_bzr_serve_then_func(
357
['--port', '127.0.0.1:0',
358
'--directory', t.local_abspath('server-root'),
360
func=self.when_server_started)
361
# The when_server_started method issued a find_repositoryV3 that should
362
# fail with 'norepository' because there are no repositories inside the
364
self.assertEqual(('norepository',), self.client_resp)
366
def when_server_started(self):
367
# Connect to the TCP server and issue some requests and see what comes
369
client_medium = medium.SmartTCPClientMedium(
370
'127.0.0.1', self.tcp_server.port,
371
'bzr://localhost:%d/' % (self.tcp_server.port,))
372
smart_client = client._SmartClient(client_medium)
373
resp = smart_client.call('mkdir', 'foo', '')
374
resp = smart_client.call('BzrDirFormat.initialize', 'foo/')
204
if sys.platform == 'win32':
205
path_to_branch = os.path.splitdrive(path_to_branch)[1]
206
branch = Branch.open(
207
'bzr+ssh://fred:secret@localhost:%d%s' % (port, path_to_branch))
209
branch.repository.get_revision_graph()
210
self.assertEqual(None, branch.last_revision())
211
# Check we can perform write operations
212
branch.bzrdir.root_transport.mkdir('foo')
214
# Restore the BZR_REMOTE_PATH environment variable back to its
216
if orig_bzr_remote_path is None:
217
del os.environ['BZR_REMOTE_PATH']
219
os.environ['BZR_REMOTE_PATH'] = orig_bzr_remote_path
222
['%s serve --inet --directory=/ --allow-writes'
224
self.command_executed)
376
resp = smart_client.call('BzrDir.find_repositoryV3', 'foo/')
377
except errors.ErrorFromSmartServer, e:
379
self.client_resp = resp
380
client_medium.disconnect()
383
class TestUserdirExpansion(TestCaseWithMemoryTransport):
386
def fake_expanduser(path):
387
"""A simple, environment-independent, function for the duration of this
390
Paths starting with a path segment of '~user' will expand to start with
391
'/home/user/'. Every other path will be unchanged.
393
if path.split('/', 1)[0] == '~user':
394
return '/home/user' + path[len('~user'):]
397
def make_test_server(self, base_path='/'):
398
"""Make and start a BzrServerFactory, backed by a memory transport, and
399
creat '/home/user' in that transport.
401
bzr_server = BzrServerFactory(
402
self.fake_expanduser, lambda t: base_path)
403
mem_transport = self.get_transport()
404
mem_transport.mkdir_multi(['home', 'home/user'])
405
bzr_server.set_up(mem_transport, None, None, inet=True, timeout=4.0)
406
self.addCleanup(bzr_server.tear_down)
409
def test_bzr_serve_expands_userdir(self):
410
bzr_server = self.make_test_server()
411
self.assertTrue(bzr_server.smart_server.backing_transport.has('~user'))
413
def test_bzr_serve_does_not_expand_userdir_outside_base(self):
414
bzr_server = self.make_test_server('/foo')
415
self.assertFalse(bzr_server.smart_server.backing_transport.has('~user'))
417
def test_get_base_path(self):
418
"""cmd_serve will turn the --directory option into a LocalTransport
419
(optionally decorated with 'readonly+'). BzrServerFactory can
420
determine the original --directory from that transport.
422
# URLs always include the trailing slash, and get_base_path returns it
423
base_dir = osutils.abspath('/a/b/c') + '/'
424
base_url = urlutils.local_path_to_url(base_dir) + '/'
425
# Define a fake 'protocol' to capture the transport that cmd_serve
426
# passes to serve_bzr.
427
def capture_transport(transport, host, port, inet, timeout):
428
self.bzr_serve_transport = transport
429
cmd = builtins.cmd_serve()
431
cmd.run(directory=base_dir, protocol=capture_transport)
432
server_maker = BzrServerFactory()
434
'readonly+%s' % base_url, self.bzr_serve_transport.base)
436
base_dir, server_maker.get_base_path(self.bzr_serve_transport))
438
cmd.run(directory=base_dir, protocol=capture_transport,
440
server_maker = BzrServerFactory()
441
self.assertEqual(base_url, self.bzr_serve_transport.base)
442
self.assertEqual(base_dir,
443
server_maker.get_base_path(self.bzr_serve_transport))
444
# Read-only, from a URL
445
cmd.run(directory=base_url, protocol=capture_transport)
446
server_maker = BzrServerFactory()
448
'readonly+%s' % base_url, self.bzr_serve_transport.base)
450
base_dir, server_maker.get_base_path(self.bzr_serve_transport))
added
removed
bzrlib/tests/blackbox/test_serve.py
