def test_stop_server(self):
backing_transport = memory.MemoryTransport()
server = chroot.ChrootServer(backing_transport)
server.start_server()
server.stop_server()
self.assertFalse(
server.scheme in transport._get_protocol_handlers().keys())
def get_chrooted_transport(url, mkdir=False):
"""Return a chrooted transport serving `url`."""
transport = get_transport(url)
if mkdir:
transport.create_prefix()
chroot_server = chroot.ChrootServer(transport)
chroot_server.start_server()
return get_transport(chroot_server.get_url())
def get_transport(self, relpath=None):
if self._chroot_server is None:
backing_transport = tests.TestCaseWithTransport.get_transport(self)
self._chroot_server = chroot.ChrootServer(backing_transport)
self._chroot_server.setUp()
self.addCleanup(self._chroot_server.tearDown)
t = get_transport(self._chroot_server.get_url())
if relpath is not None:
t = t.clone(relpath)
return t
def test_clone(self):
server = chroot.ChrootServer(
transport.get_transport_from_url('memory:///foo/bar/'))
self.start_server(server)
t = transport.get_transport_from_url(server.get_url())
# relpath from root and root path are the same
relpath_cloned = t.clone('foo')
abspath_cloned = t.clone('/foo')
self.assertEqual(server, relpath_cloned.server)
self.assertEqual(server, abspath_cloned.server)
def test_abspath(self):
# The abspath is always relative to the chroot_url.
server = chroot.ChrootServer(
transport.get_transport_from_url('memory:///foo/bar/'))
self.start_server(server)
t = transport.get_transport_from_url(server.get_url())
self.assertEqual(server.get_url(), t.abspath('/'))
subdir_t = t.clone('subdir')
self.assertEqual(server.get_url(), subdir_t.abspath('/'))
def do_POST(self):
"""Hand the request off to a smart server instance."""
backing = get_transport(self.server.test_case_server._home_dir)
chroot_server = chroot.ChrootServer(backing)
chroot_server.setUp()
try:
t = get_transport(chroot_server.get_url())
self.do_POST_inner(t)
finally:
chroot_server.tearDown()
def do_POST(self):
"""Hand the request off to a smart server instance."""
backing = transport.get_transport_from_path(
self.server.test_case_server._home_dir)
chroot_server = chroot.ChrootServer(backing)
chroot_server.start_server()
try:
t = transport.get_transport_from_url(chroot_server.get_url())
self.do_POST_inner(t)
finally:
chroot_server.stop_server()
def test_urljoin_preserves_chroot(self):
"""Using urlutils.join(url, '..') on a chroot URL should not produce a
URL that escapes the intended chroot.
This is so that it is not possible to escape a chroot by doing::
url = chroot_transport.base
parent_url = urlutils.join(url, '..')
new_t = transport.get_transport_from_url(parent_url)
"""
server = chroot.ChrootServer(
transport.get_transport_from_url('memory:///path/'))
self.start_server(server)
t = transport.get_transport_from_url(server.get_url())
self.assertRaises(errors.InvalidURLJoin, urlutils.join, t.base, '..')
def get_chrooted_scheme(self, relpath):
"""Create a server that is chrooted to `relpath`.
:return: ``(scheme, get_url)`` where ``scheme`` is the scheme of the
chroot server and ``get_url`` returns URLs on said server.
"""
transport = self.get_transport(relpath)
chroot_server = chroot.ChrootServer(transport)
chroot_server.start_server()
self.addCleanup(chroot_server.stop_server)
def get_url(relpath):
return chroot_server.get_url() + relpath
return URI(chroot_server.get_url()).scheme, get_url
def __init__(self, backing_transport, root_client_path='/'):
"""Constructor.
:param backing_transport: a transport. Requests will be processed
relative to this transport.
:param root_client_path: the client path that maps to the root of
backing_transport. This is used to interpret relpaths received from
the client.
"""
# Use a ChrootServer so that this web application won't
# accidentally let people access locations they shouldn't.
# e.g. consider a smart server request for "get /etc/passwd" or
# something.
self.chroot_server = chroot.ChrootServer(backing_transport)
self.chroot_server.start_server()
self.backing_transport = get_transport(self.chroot_server.get_url())
self.root_client_path = root_client_path
def test_chroot_url_preserves_chroot(self):
"""Calling get_transport on a chroot transport's base should produce a
transport with exactly the same behaviour as the original chroot
transport.
This is so that it is not possible to escape a chroot by doing::
url = chroot_transport.base
parent_url = urlutils.join(url, '..')
new_t = transport.get_transport_from_url(parent_url)
"""
server = chroot.ChrootServer(
transport.get_transport_from_url('memory:///path/subpath'))
self.start_server(server)
t = transport.get_transport_from_url(server.get_url())
new_t = transport.get_transport_from_url(t.base)
self.assertEqual(t.server, new_t.server)
self.assertEqual(t.base, new_t.base)
def _transportFactory(self, url):
"""See `LaunchpadInternalServer._transportFactory`.
As `LaunchpadTransport` 'acts all kinds of crazy' above the .bzr
directory of a branch (forbidding file or directory creation at some
levels, enforcing naming restrictions at others), we test a
LaunchpadTransport chrooted into the .bzr directory of a branch.
"""
if not url.startswith(self._scheme):
raise AssertionError("Wrong transport scheme.")
root_transport = LaunchpadInternalServer._transportFactory(
self, self._scheme)
relpath = root_transport.relpath(url)
bzrdir_transport = root_transport.clone(
self._branch_path).clone('.bzr')
bzrdir_transport.ensure_base()
chroot_server = chroot.ChrootServer(bzrdir_transport)
chroot_server.start_server()
self._chroot_servers.append(chroot_server)
return get_transport(chroot_server.get_url()).clone(relpath)
def test_get_url(self):
backing_transport = memory.MemoryTransport()
server = chroot.ChrootServer(backing_transport)
server.start_server()
self.addCleanup(server.stop_server)
self.assertEqual('chroot-%d:///' % id(server), server.get_url())
def test_construct(self):
backing_transport = memory.MemoryTransport()
server = chroot.ChrootServer(backing_transport)
self.assertEqual(backing_transport, server.backing_transport)
