1
# Copyright (C) 2006 Canonical Ltd
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.
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.
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
18
"""Tests of the bzr serve command."""
30
revision as _mod_revision,
33
from bzrlib.branch import Branch
34
from bzrlib.bzrdir import BzrDir
35
from bzrlib.errors import ParamikoNotPresent
36
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):
45
def assertInetServerShutsdownCleanly(self, process):
46
"""Shutdown the server process looking for errors."""
47
# Shutdown the server: the server should shut down when it cannot read
50
# Hide stdin from the subprocess module, so it won't fail to close it.
52
result = self.finish_bzr_subprocess(process)
53
self.assertEqual('', result[0])
54
self.assertEqual('', result[1])
56
def assertServerFinishesCleanly(self, process):
57
"""Shutdown the bzr serve instance process looking for errors."""
59
result = self.finish_bzr_subprocess(process, retcode=3,
60
send_signal=signal.SIGINT)
61
self.assertEqual('', result[0])
62
self.assertEqual('bzr: interrupted\n', result[1])
64
def make_read_requests(self, branch):
65
"""Do some read only requests."""
68
branch.repository.all_revision_ids()
69
self.assertEqual(_mod_revision.NULL_REVISION,
70
_mod_revision.ensure_null(branch.last_revision()))
74
def start_server_inet(self, extra_options=()):
75
"""Start a bzr server subprocess using the --inet option.
77
:param extra_options: extra options to give the server.
78
:return: a tuple with the bzr process handle for passing to
79
finish_bzr_subprocess, a client for the server, and a transport.
81
# Serve from the current directory
82
process = self.start_bzr_subprocess(['serve', '--inet'])
84
# Connect to the server
85
# We use this url because while this is no valid URL to connect to this
86
# server instance, the transport needs a URL.
87
url = 'bzr://localhost/'
88
client_medium = medium.SmartSimplePipesClientMedium(
89
process.stdout, process.stdin, url)
90
transport = remote.RemoteTransport(url, medium=client_medium)
91
return process, transport
93
def start_server_port(self, extra_options=()):
94
"""Start a bzr server subprocess.
96
:param extra_options: extra options to give the server.
97
:return: a tuple with the bzr process handle for passing to
98
finish_bzr_subprocess, and the base url for the server.
100
# Serve from the current directory
101
args = ['serve', '--port', 'localhost:0']
102
args.extend(extra_options)
103
process = self.start_bzr_subprocess(args, skip_if_plan_to_signal=True)
104
port_line = process.stderr.readline()
105
prefix = 'listening on port: '
106
self.assertStartsWith(port_line, prefix)
107
port = int(port_line[len(prefix):])
108
return process,'bzr://localhost:%d/' % port
110
def test_bzr_serve_inet_readonly(self):
111
"""bzr server should provide a read only filesystem by default."""
112
process, transport = self.start_server_inet()
113
self.assertRaises(errors.TransportNotPossible, transport.mkdir, 'adir')
114
self.assertInetServerShutsdownCleanly(process)
116
def test_bzr_serve_inet_readwrite(self):
118
self.make_branch('.')
120
process, transport = self.start_server_inet(['--allow-writes'])
122
# We get a working branch
123
branch = BzrDir.open_from_transport(transport).open_branch()
124
self.make_read_requests(branch)
125
self.assertInetServerShutsdownCleanly(process)
127
def test_bzr_serve_port_readonly(self):
128
"""bzr server should provide a read only filesystem by default."""
129
process, url = self.start_server_port()
130
transport = get_transport(url)
131
self.assertRaises(errors.TransportNotPossible, transport.mkdir, 'adir')
132
self.assertServerFinishesCleanly(process)
134
def test_bzr_serve_port_readwrite(self):
136
self.make_branch('.')
138
process, url = self.start_server_port(['--allow-writes'])
140
# Connect to the server
141
branch = Branch.open(url)
142
self.make_read_requests(branch)
143
self.assertServerFinishesCleanly(process)
145
def test_bzr_serve_supports_protocol(self):
147
self.make_branch('.')
149
process, url = self.start_server_port(['--allow-writes',
152
# Connect to the server
153
branch = Branch.open(url)
154
self.make_read_requests(branch)
155
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.
212
self.start_server(ssh_server)
213
port = ssh_server._listener.port
215
# Access the branch via a bzr+ssh URL. The BZR_REMOTE_PATH environment
216
# variable is used to tell bzr what command to run on the remote end.
217
path_to_branch = osutils.abspath('a_branch')
219
orig_bzr_remote_path = os.environ.get('BZR_REMOTE_PATH')
220
bzr_remote_path = self.get_bzr_path()
221
if sys.platform == 'win32':
222
bzr_remote_path = sys.executable + ' ' + self.get_bzr_path()
223
os.environ['BZR_REMOTE_PATH'] = bzr_remote_path
225
if sys.platform == 'win32':
226
path_to_branch = os.path.splitdrive(path_to_branch)[1]
227
branch = Branch.open(
228
'bzr+ssh://fred:secret@localhost:%d%s' % (port, path_to_branch))
229
self.make_read_requests(branch)
230
# Check we can perform write operations
231
branch.bzrdir.root_transport.mkdir('foo')
233
# Restore the BZR_REMOTE_PATH environment variable back to its
235
if orig_bzr_remote_path is None:
236
del os.environ['BZR_REMOTE_PATH']
238
os.environ['BZR_REMOTE_PATH'] = orig_bzr_remote_path
241
['%s serve --inet --directory=/ --allow-writes'
243
self.command_executed)
246
class TestCmdServeChrooting(TestCaseWithTransport):
248
def test_serve_tcp(self):
249
"""'bzr serve' wraps the given --directory in a ChrootServer.
251
So requests that search up through the parent directories (like
252
find_repositoryV3) will give "not found" responses, rather than
253
InvalidURLJoin or jail break errors.
255
t = self.get_transport()
256
t.mkdir('server-root')
257
self.run_bzr_serve_then_func(
258
['--port', '0', '--directory', t.local_abspath('server-root'),
260
self.when_server_started)
261
# The when_server_started method issued a find_repositoryV3 that should
262
# fail with 'norepository' because there are no repositories inside the
264
self.assertEqual(('norepository',), self.client_resp)
266
def run_bzr_serve_then_func(self, serve_args, func, *func_args,
268
"""Run 'bzr serve', and run the given func in a thread once the server
271
When 'func' terminates, the server will be terminated too.
274
def on_server_start(backing_urls, tcp_server):
275
t = threading.Thread(
276
target=on_server_start_thread, args=(tcp_server,))
278
def on_server_start_thread(tcp_server):
281
self.tcp_server = tcp_server
283
func(*func_args, **func_kwargs)
285
# Log errors to make some test failures a little less
287
mutter('func broke: %r', e)
289
# Then stop the server
290
mutter('interrupting...')
291
thread.interrupt_main()
292
SmartTCPServer.hooks.install_named_hook(
293
'server_started_ex', on_server_start,
294
'run_bzr_serve_then_func hook')
297
self.run_bzr(['serve'] + list(serve_args))
298
except KeyboardInterrupt:
301
def when_server_started(self):
302
# Connect to the TCP server and issue some requests and see what comes
304
client_medium = medium.SmartTCPClientMedium(
305
'127.0.0.1', self.tcp_server.port,
306
'bzr://localhost:%d/' % (self.tcp_server.port,))
307
smart_client = client._SmartClient(client_medium)
308
resp = smart_client.call('mkdir', 'foo', '')
309
resp = smart_client.call('BzrDirFormat.initialize', 'foo/')
311
resp = smart_client.call('BzrDir.find_repositoryV3', 'foo/')
312
except errors.ErrorFromSmartServer, e:
314
self.client_resp = resp
315
client_medium.disconnect()
added
removed
bzrlib/tests/blackbox/test_serve.py
