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)