from tasks.cephfs.cephfs_test_case import CephFSTestCase
from tasks.cephfs.fuse_mount import FuseMount
from teuthology.exceptions import CommandFailedError
-from teuthology.misc import sudo_write_file
log = logging.getLogger(__name__)
# One for looking at the global filesystem, one for being
# the VolumeClient, two for mounting the created shares
CLIENTS_REQUIRED = 4
- default_py_version = 'python3'
def setUp(self):
CephFSTestCase.setUp(self)
- self.py_version = self.ctx.config.get('overrides', {}).\
- get('python3', TestVolumeClient.default_py_version)
- log.info("using python version: {python_version}".format(
- python_version=self.py_version
- ))
def _volume_client_python(self, client, script, vol_prefix=None, ns_prefix=None):
# Can't dedent this *and* the script we pass in, because they might have different
{payload}
vc.disconnect()
""".format(payload=script, conf_path=client.config_path,
- vol_prefix=vol_prefix, ns_prefix=ns_prefix),
- self.py_version)
+ vol_prefix=vol_prefix, ns_prefix=ns_prefix))
def _configure_vc_auth(self, mount, id_name):
"""
"mon", "allow *"
)
mount.client_id = id_name
- sudo_write_file(mount.client_remote, mount.get_keyring_path(), out)
+ mount.client_remote.write_file(mount.get_keyring_path(),
+ out, sudo=True)
self.set_conf("client.{name}".format(name=id_name), "keyring", mount.get_keyring_path())
def _configure_guest_auth(self, volumeclient_mount, guest_mount,
- guest_entity, mount_path,
+ guest_entity, cephfs_mntpt,
namespace_prefix=None, readonly=False,
tenant_id=None, allow_existing_id=False):
"""
volumeclient.
:param guest_mount: mount used by the guest client.
:param guest_entity: auth ID used by the guest client.
- :param mount_path: path of the volume.
+ :param cephfs_mntpt: path of the volume.
:param namespace_prefix: name prefix of the RADOS namespace, which
is used for the volume's layout.
:param readonly: defaults to False. If set to 'True' only read-only
:param tenant_id: (OpenStack) tenant ID of the guest client.
"""
- head, volume_id = os.path.split(mount_path)
+ head, volume_id = os.path.split(cephfs_mntpt)
head, group_id = os.path.split(head)
head, volume_prefix = os.path.split(head)
volume_prefix = "/" + volume_prefix
key=key
))
guest_mount.client_id = guest_entity
- sudo_write_file(guest_mount.client_remote,
- guest_mount.get_keyring_path(), keyring_txt)
+ guest_mount.client_remote.write_file(guest_mount.get_keyring_path(),
+ keyring_txt, sudo=True)
# Add a guest client section to the ceph config file.
self.set_conf("client.{0}".format(guest_entity), "client quota", "True")
# Create a 100MB volume
volume_size = 100
- mount_path = self._volume_client_python(self.mount_b, dedent("""
+ cephfs_mntpt = self._volume_client_python(self.mount_b, dedent("""
vp = VolumePath("{group_id}", "{volume_id}")
create_result = vc.create_volume(vp, 1024*1024*{volume_size})
print(create_result['mount_path'])
# Authorize and configure credentials for the guest to mount the
# the volume.
self._configure_guest_auth(self.mount_b, self.mounts[2], guest_entity,
- mount_path, namespace_prefix)
- self.mounts[2].mount(mount_path=mount_path)
+ cephfs_mntpt, namespace_prefix)
+ self.mounts[2].mount_wait(cephfs_mntpt=cephfs_mntpt)
# The kernel client doesn't have the quota-based df behaviour,
# or quotas at all, so only exercise the client behaviour when
try:
background.wait()
except CommandFailedError:
- # command failed with EBLACKLISTED?
+ # command failed with EBLOCKLISTED?
if "transport endpoint shutdown" in background.stderr.getvalue():
pass
else:
guest_entity = "guest"
group_id = "grpid"
- mount_paths = []
+ cephfs_mntpts = []
volume_ids = []
# Create two volumes. Authorize 'guest' auth ID to mount the two
for i in range(2):
# Create volume.
volume_ids.append("volid_{0}".format(str(i)))
- mount_paths.append(
+ cephfs_mntpts.append(
self._volume_client_python(volumeclient_mount, dedent("""
vp = VolumePath("{group_id}", "{volume_id}")
create_result = vc.create_volume(vp, 10 * 1024 * 1024)
# Authorize 'guest' auth ID to mount the volume.
self._configure_guest_auth(volumeclient_mount, guest_mounts[i],
- guest_entity, mount_paths[i])
+ guest_entity, cephfs_mntpts[i])
# Mount the volume.
guest_mounts[i].mountpoint_dir_name = 'mnt.{id}.{suffix}'.format(
id=guest_entity, suffix=str(i))
- guest_mounts[i].mount(mount_path=mount_paths[i])
+ guest_mounts[i].mount_wait(cephfs_mntpt=cephfs_mntpts[i])
guest_mounts[i].write_n_mb("data.bin", 1)
# Evicted guest client, guest_mounts[0], should not be able to do
# anymore metadata ops. It should start failing all operations
- # when it sees that its own address is in the blacklist.
+ # when it sees that its own address is in the blocklist.
try:
guest_mounts[0].write_n_mb("rogue.bin", 1)
except CommandFailedError:
else:
raise RuntimeError("post-eviction write should have failed!")
- # The blacklisted guest client should now be unmountable
+ # The blocklisted guest client should now be unmountable
guest_mounts[0].umount_wait()
# Guest client, guest_mounts[1], using the same auth ID 'guest', but
volume_id = u"volid"
# Create
- mount_path = self._volume_client_python(self.mount_b, dedent("""
+ cephfs_mntpt = self._volume_client_python(self.mount_b, dedent("""
vp = VolumePath("{group_id}", u"{volume_id}")
create_result = vc.create_volume(vp, 10)
print(create_result['mount_path'])
)))
# Strip leading "/"
- mount_path = mount_path[1:]
+ cephfs_mntpt = cephfs_mntpt[1:]
# A file with non-ascii characters
- self.mount_a.run_shell(["touch", os.path.join(mount_path, u"b\u00F6b")])
+ self.mount_a.run_shell(["touch", os.path.join(cephfs_mntpt, u"b\u00F6b")])
# A file with no permissions to do anything
- self.mount_a.run_shell(["touch", os.path.join(mount_path, "noperms")])
- self.mount_a.run_shell(["chmod", "0000", os.path.join(mount_path, "noperms")])
+ self.mount_a.run_shell(["touch", os.path.join(cephfs_mntpt, "noperms")])
+ self.mount_a.run_shell(["chmod", "0000", os.path.join(cephfs_mntpt, "noperms")])
self._volume_client_python(self.mount_b, dedent("""
vp = VolumePath("{group_id}", u"{volume_id}")
volume_id = "volid"
# Create a volume.
- mount_path = self._volume_client_python(volumeclient_mount, dedent("""
+ cephfs_mntpt = self._volume_client_python(volumeclient_mount, dedent("""
vp = VolumePath("{group_id}", "{volume_id}")
create_result = vc.create_volume(vp, 1024*1024*10)
print(create_result['mount_path'])
# Authorize and configure credentials for the guest to mount the
# the volume with read-write access.
- self._configure_guest_auth(volumeclient_mount, guest_mount, guest_entity,
- mount_path, readonly=False)
+ self._configure_guest_auth(volumeclient_mount, guest_mount,
+ guest_entity, cephfs_mntpt, readonly=False)
# Mount the volume, and write to it.
- guest_mount.mount(mount_path=mount_path)
+ guest_mount.mount_wait(cephfs_mntpt=cephfs_mntpt)
guest_mount.write_n_mb("data.bin", 1)
# Change the guest auth ID's authorization to read-only mount access.
guest_entity=guest_entity
)))
self._configure_guest_auth(volumeclient_mount, guest_mount, guest_entity,
- mount_path, readonly=True)
+ cephfs_mntpt, readonly=True)
# The effect of the change in access level to read-only is not
# immediate. The guest sees the change only after a remount of
# the volume.
guest_mount.umount_wait()
- guest_mount.mount(mount_path=mount_path)
+ guest_mount.mount_wait(cephfs_mntpt=cephfs_mntpt)
# Read existing content of the volume.
self.assertListEqual(guest_mount.ls(guest_mount.mountpoint), ["data.bin"])
guest_entity_2=guest_entity_2,
)))
# Check the list of authorized IDs and their access levels.
- if self.py_version == 'python3':
- expected_result = [('guest1', 'rw'), ('guest2', 'r')]
- self.assertCountEqual(str(expected_result), auths)
- else:
- expected_result = [(u'guest1', u'rw'), (u'guest2', u'r')]
- self.assertItemsEqual(str(expected_result), auths)
+ expected_result = [('guest1', 'rw'), ('guest2', 'r')]
+ self.assertCountEqual(str(expected_result), auths)
# Disallow both the auth IDs' access to the volume.
auths = self._volume_client_python(volumeclient_mount, dedent("""
# Create a volume
group_id = "grpid"
volume_id = "volid"
- mount_path = self._volume_client_python(vc_mount, dedent("""
+ cephfs_mntpt = self._volume_client_python(vc_mount, dedent("""
vp = VolumePath("{group_id}", "{volume_id}")
create_result = vc.create_volume(vp, 1024*1024*10)
print(create_result['mount_path'])
guest_mount = self.mounts[2]
guest_mount.umount_wait()
-
- # Set auth caps for the auth ID using the volumeclient
- self._configure_guest_auth(vc_mount, guest_mount, guest_id, mount_path,
+# Set auth caps for the auth ID using the volumeclient
+ self._configure_guest_auth(vc_mount, guest_mount, guest_id, cephfs_mntpt,
allow_existing_id=True)
# Mount the volume in the guest using the auth ID to assert that the
# auth caps are valid
- guest_mount.mount(mount_path=mount_path)
+ guest_mount.mount_wait(cephfs_mntpt=cephfs_mntpt)
def test_volume_without_namespace_isolation(self):
"""
projects / ceph.git / blobdiff