def test_filesystem_udev_symlink_fsrename_poolrename(self):
"""
Test the udev symlink creation for filesystem devices after fs and pool rename.
"""
pool_name = p_n()
pool_path = make_test_pool(pool_name, StratisCertify.DISKS[0:1])
fs_name = fs_n()
filesystem_path = make_test_filesystem(pool_path, fs_name)
fs_name_rename = fs_n()
self._unittest_command(
StratisDbus.fs_rename(pool_name, fs_name, fs_name_rename),
dbus.UInt16(0))
# Settle after rename, to allow udev to recognize the filesystem rename
exec_command(["udevadm", "settle"])
pool_name_rename = p_n()
self._unittest_command(
StratisDbus.pool_rename(pool_name, pool_name_rename),
dbus.UInt16(0))
# Settle after rename, to allow udev to recognize the pool rename
exec_command(["udevadm", "settle"])
fsdevdest, fsdevmapperlinkdest = acquire_filesystem_symlink_targets(
pool_name_rename, fs_name_rename, pool_path, filesystem_path)
self.assertEqual(fsdevdest, fsdevmapperlinkdest)
def test_pool_destroy(self):
"""
Test destroying a pool.
"""
pool_name = p_n()
make_test_pool(pool_name, StratisCertify.DISKS[0:1])
self._unittest_command(StratisDbus.pool_destroy(pool_name), dbus.UInt16(0))
self.assertEqual(StratisDbus.fs_list(), {})
def set_key():
"""
Set up a keyfile and set the value of the key in the kernel
keyring.
"""
with NamedTemporaryFile(mode="w") as temp_file:
temp_file.write("test-password")
temp_file.flush()
StratisDbus.set_key(key_desc, temp_file)
def test_pool_destroy(self):
"""
Test destroying a pool.
"""
pool_name = p_n()
make_test_pool(pool_name, DISKS[0:1])
(_, return_code, _) = StratisDbus.pool_destroy(pool_name)
self.assertEqual(return_code, dbus.UInt16(0))
self.assertEqual(StratisDbus.fs_list(), {})
def test_get_report(self):
"""
Test getting a valid and invalid report.
"""
(result, return_code, _) = StratisDbus.get_report("stopped_pools")
self._inequality_test(result, dbus.String(""))
self.assertEqual(return_code, dbus.UInt16(0))
# Test that we have received valid JSON.
json.loads(result)
(result, return_code, _) = StratisDbus.get_report("invalid_report")
self.assertEqual(result, dbus.String(""))
self._inequality_test(return_code, dbus.UInt16(0))
def test_filesystem_destroy(self):
"""
Test destroying a filesystem.
"""
pool_name = p_n()
pool_path = make_test_pool(pool_name, DISKS[0:1])
fs_name = fs_n()
make_test_filesystem(pool_path, fs_name)
(_, return_code, _) = StratisDbus.fs_destroy(pool_name, fs_name)
self.assertEqual(return_code, dbus.UInt16(0))
self.assertEqual(StratisDbus.fs_list(), {})
def test_key_set_unset(self):
"""
Test setting a key.
"""
key_desc = "test-description"
with NamedTemporaryFile(mode="w") as temp_file:
temp_file.write("test-password")
temp_file.flush()
self._unittest_command(StratisDbus.set_key(key_desc, temp_file),
dbus.UInt16(0))
self._unittest_command(StratisDbus.unset_key(key_desc), dbus.UInt16(0))
def test_filesystem_destroy(self):
"""
Test destroying a filesystem.
"""
pool_name = p_n()
pool_path = make_test_pool(pool_name, StratisCertify.DISKS[0:1])
fs_name = fs_n()
make_test_filesystem(pool_path, fs_name)
self._unittest_command(StratisDbus.fs_destroy(pool_name, fs_name),
dbus.UInt16(0))
self.assertEqual(StratisDbus.fs_list(), {})
def _test_permissions(self,
dbus_method,
args,
permissions,
*,
kwargs=None):
"""
Test running dbus_method with and without root permissions.
:param dbus_method: D-Bus method to be tested
:type dbus_method: StratisDbus method
:param args: the arguments to be passed to the D-Bus method
:type args: list of objects
:param bool permissions: True if dbus_method needs root permissions to succeed.
False if dbus_method should succeed without root permissions.
:param kwargs: the keyword arguments to be passed to the D-Bus method
:type kwargs: dict of objects or NoneType
"""
kwargs = {} if kwargs is None else kwargs
_permissions_flag = False
euid = os.geteuid()
if euid != _ROOT:
raise RuntimeError(
f"This process should be running as root, but the current euid is {euid}."
)
os.seteuid(_NON_ROOT)
StratisDbus.reconnect()
try:
dbus_method(*args, **kwargs)
except dbus.exceptions.DBusException as err:
if err.get_dbus_name(
) == "org.freedesktop.DBus.Error.AccessDenied":
_permissions_flag = True
else:
os.seteuid(_ROOT)
raise err
except Exception as err:
os.seteuid(_ROOT)
raise err
os.seteuid(_ROOT)
StratisDbus.reconnect()
dbus_method(*args, **kwargs)
self.assertEqual(_permissions_flag, permissions)
def test_pool_create_with_cache(self):
"""
Test creating existing pool with device already used by cache fails
"""
pool_name = p_n()
pool_path = make_test_pool(pool_name, StratisCertify.DISKS[0:1])
self._unittest_command(
StratisDbus.pool_init_cache(pool_path, StratisCertify.DISKS[1:2]),
dbus.UInt16(0),
)
self._unittest_command(
StratisDbus.pool_create(pool_name, StratisCertify.DISKS[0:2]),
dbus.UInt16(1),
)
def test_pool_add_different_data_after_cache(self):
"""
Test adding a different data device after a cache is created.
"""
pool_name = p_n()
pool_path = make_test_pool(pool_name, StratisCertify.DISKS[0:1])
self._unittest_command(
StratisDbus.pool_init_cache(pool_path, StratisCertify.DISKS[1:2]),
dbus.UInt16(0),
)
self._unittest_command(
StratisDbus.pool_add_data(pool_path, StratisCertify.DISKS[2:3]),
dbus.UInt16(0),
)
def test_pool_create_after_cache(self):
"""
Test creating existing pool after cache was added
"""
pool_name = p_n()
pool_path = make_test_pool(pool_name, StratisCertify.DISKS[0:1])
self._unittest_command(
StratisDbus.pool_init_cache(pool_path, StratisCertify.DISKS[1:2]),
dbus.UInt16(0),
)
self._unittest_command(
StratisDbus.pool_create(pool_name, StratisCertify.DISKS[0:1]),
dbus.UInt16(0),
)
def test_pool_add_cache(self):
"""
Test adding cache to a pool.
"""
pool_name = p_n()
pool_path = make_test_pool(pool_name, StratisCertify.DISKS[0:1])
self._unittest_command(
StratisDbus.pool_init_cache(pool_path, StratisCertify.DISKS[1:2]),
dbus.UInt16(0),
)
self._unittest_command(
StratisDbus.pool_add_cache(pool_path, StratisCertify.DISKS[2:3]),
dbus.UInt16(0),
)
def test_filesystem_list_empty(self):
"""
Test listing an non-existent filesystem.
"""
result = StratisDbus.fs_list()
self.assertIsInstance(result, dict)
self.assertEqual(result, {})
def test_pool_create(self):
"""
Test creating a pool.
"""
pool_name = p_n()
(_, return_code, _) = StratisDbus.pool_create(pool_name, DISKS)
self.assertEqual(return_code, dbus.UInt16(0))
def test_blockdev_list(self):
"""
Test listing a blockdev.
"""
result = StratisDbus.blockdev_list()
self.assertIsInstance(result, list)
self.assertEqual(result, [])
def acquire_filesystem_symlink_targets(pool_name, filesystem_name, pool_path,
filesystem_path):
"""
Acquire the symlink targets of the "/dev/stratis" symlink,
and the equivalent device-mapper "/dev/mapper" link, generated
via the info from get_managed_objects().
NOTE: This may require a preceding "udevadm settle" call, to
ensure that up-to-date pool and filesystem information is being
collected.
:param str pool_name: pool name
:param str filesystem_name: filesystem name
:param str pool_path: pool path
:param str filesystem_path: filesystem path
:return: str fsdevdest, str fsdevmapperlinkdest
"""
objects = StratisDbus.get_managed_objects()
pool_gmodata = objects[pool_path]
pool_uuid = pool_gmodata[StratisDbus.POOL_IFACE]["Uuid"]
filesystem_gmodata = objects[filesystem_path]
filesystem_uuid = filesystem_gmodata[StratisDbus.FS_IFACE]["Uuid"]
filesystem_devnode = "/dev/stratis/" + pool_name + "/" + filesystem_name
fs_devmapperlinkstr = ("/dev/mapper/stratis-1-" + pool_uuid + "-thin-fs-" +
filesystem_uuid)
fsdevdest = resolve_symlink(filesystem_devnode)
fsdevmapperlinkdest = resolve_symlink(fs_devmapperlinkstr)
return fsdevdest, fsdevmapperlinkdest
def test_get_keys(self):
"""
Test getting the Stratis keys in the kernel keyring.
"""
(_, return_code, _) = StratisDbus.get_keys()
self.assertEqual(return_code, dbus.UInt16(0))
def test_pool_list_empty(self):
"""
Test listing an non-existent pool.
"""
result = StratisDbus.pool_list()
self.assertIsInstance(result, list)
self.assertEqual(result, [])
def test_stratisd_version(self):
"""
Test getting the daemon version.
"""
result = StratisDbus.stratisd_version()
self.assertIsInstance(result, str)
self.assertNotEqual(result, "")
def setUp(self):
"""
Setup for an individual test.
* Register a cleanup action, to be run if the test fails.
* Ensure that stratisd is running via systemd.
* Use the running stratisd instance to destroy any existing
Stratis filesystems, pools, etc.
:return: None
"""
self.addCleanup(clean_up)
if process_exists("stratisd") is None:
exec_command(["systemctl", "start", "stratisd"])
time.sleep(20)
StratisDbus.destroy_all()
assert StratisDbus.pool_list() == []
def test_pool_list_not_empty(self):
"""
Test listing an non-existent pool.
"""
pool_name = p_n()
make_test_pool(pool_name, StratisCertify.DISKS[0:1])
self._inequality_test(StratisDbus.pool_list(), [])
def test_pool_create_same_name_different_devices(self):
"""
Test creating a pool that already exists with different devices.
"""
pool_name = p_n()
make_test_pool(pool_name, DISKS[0:1])
(_, return_code, _) = StratisDbus.pool_create(pool_name, DISKS[1:3])
self.assertEqual(return_code, dbus.UInt16(1))
def test_pool_add_data(self):
"""
Test adding data to a pool.
"""
pool_name = p_n()
pool_path = make_test_pool(pool_name, DISKS[0:2])
(_, return_code, _) = StratisDbus.pool_add_data(pool_path, DISKS[2:3])
self.assertEqual(return_code, dbus.UInt16(0))
def test_engine_state_report(self):
"""
Test getting a valid engine state report
"""
(result, return_code, _) = StratisDbus.get_engine_state_report()
self._inequality_test(result, dbus.String(""))
self.assertEqual(return_code, dbus.UInt16(0))
# Test that we have received valid JSON.
json.loads(result)
def test_pool_create(self):
"""
Test creating a pool.
"""
pool_name = p_n()
self._unittest_command(
StratisDbus.pool_create(pool_name, StratisCertify.DISKS),
dbus.UInt16(0),
)
def test_pool_list_not_empty(self):
"""
Test listing an non-existent pool.
"""
pool_name = p_n()
make_test_pool(pool_name, DISKS[0:1])
result = StratisDbus.pool_list()
self.assertIsInstance(result, list)
self.assertNotEqual(result, [])
def test_filesystem_list_not_empty(self):
"""
Test listing an existent filesystem.
"""
pool_name = p_n()
pool_path = make_test_pool(pool_name, StratisCertify.DISKS[0:1])
fs_name = fs_n()
make_test_filesystem(pool_path, fs_name)
self._inequality_test(StratisDbus.fs_list(), {})
def test_filesystem_create(self):
"""
Test creating a filesystem.
"""
pool_name = p_n()
pool_path = make_test_pool(pool_name, StratisCertify.DISKS[0:1])
fs_name = fs_n()
self._unittest_command(StratisDbus.fs_create(pool_path, fs_name),
dbus.UInt16(0))
def test_pool_create_same_name_different_devices(self):
"""
Test creating a pool that already exists with different devices.
"""
pool_name = p_n()
make_test_pool(pool_name, StratisCertify.DISKS[0:1])
self._unittest_command(
StratisDbus.pool_create(pool_name, StratisCertify.DISKS[1:3]),
dbus.UInt16(1),
)
