Merge pull request #1181 from vojtechtrefny/3.9-devel_md-tests

tests: Add storage test case for MD RAID

blivet/devices/md.py

@@ -634,6 +634,8 @@ def _remove(self, member):
             blockdev.md.remove(self.path, member.path, fail)
         except blockdev.MDRaidError as err:
             raise errors.MDRaidError(err)
+        finally:
+            member.format.md_uuid = None
 
     def _add(self, member):
         """ Add a member device to an array.
@@ -644,7 +646,7 @@ def _add(self, member):
         """
         self.setup()
 
-        raid_devices = None
+        raid_devices = 0
         try:
             if not self.level.has_redundancy():
                 if self.level is not raid.Linear:
@@ -656,6 +658,8 @@ def _add(self, member):
             blockdev.md.add(self.path, member.path, raid_devs=raid_devices)
         except blockdev.MDRaidError as err:
             raise errors.MDRaidError(err)
+        finally:
+            member.format.md_uuid = self.uuid
 
     @property
     def format_args(self):

tests/storage_tests/devices_test/__init__.py

@@ -1,4 +1,5 @@
 from .btrfs_test import *
 from .lvm_test import *
+from .md_test import *
 from .partition_test import *
 from .stratis_test import *

tests/storage_tests/devices_test/md_test.py

@@ -0,0 +1,183 @@
+import os
+
+from ..storagetestcase import StorageTestCase
+
+import blivet
+
+
+class MDTestCase(StorageTestCase):
+
+    raidname = "blivetTestRAID"
+
+    def setUp(self):
+        super().setUp()
+
+        disks = [os.path.basename(vdev) for vdev in self.vdevs]
+        self.storage = blivet.Blivet()
+        self.storage.exclusive_disks = disks
+        self.storage.reset()
+
+        # make sure only the targetcli disks are in the devicetree
+        for disk in self.storage.disks:
+            self.assertTrue(disk.path in self.vdevs)
+            self.assertIsNone(disk.format.type)
+            self.assertFalse(disk.children)
+
+    def _clean_up(self):
+        self.storage.reset()
+        for disk in self.storage.disks:
+            if disk.path not in self.vdevs:
+                raise RuntimeError("Disk %s found in devicetree but not in disks created for tests" % disk.name)
+            self.storage.recursive_remove(disk)
+
+        self.storage.do_it()
+
+        return super()._clean_up()
+
+    def _prepare_members(self, members):
+        parts = []
+        for i in range(members):
+            disk = self.storage.devicetree.get_device_by_path(self.vdevs[i])
+            self.assertIsNotNone(disk)
+            self.storage.initialize_disk(disk)
+
+            part = self.storage.new_partition(size=blivet.size.Size("100 MiB"), fmt_type="mdmember",
+                                              parents=[disk])
+            self.storage.create_device(part)
+            parts.append(part)
+
+        blivet.partitioning.do_partitioning(self.storage)
+
+        return parts
+
+    def _test_mdraid(self, raid_level, members):
+        parts = self._prepare_members(members)
+        array = self.storage.new_mdarray(name=self.raidname, parents=parts,
+                                         level=raid_level, total_devices=members,
+                                         member_devices=members)
+        self.storage.create_device(array)
+
+        self.storage.do_it()
+        self.storage.reset()
+
+        array = self.storage.devicetree.get_device_by_name(self.raidname)
+        self.assertIsNotNone(array)
+        self.assertEqual(array.level, raid_level)
+        self.assertEqual(array.member_devices, members)
+        self.assertEqual(array.spares, 0)
+        self.assertCountEqual([m.name for m in array.members],
+                              [p.name for p in parts])
+        for member in array.members:
+            self.assertEqual(member.format.md_uuid, array.uuid)
+
+    def test_mdraid_raid0(self):
+        self._test_mdraid(blivet.devicelibs.raid.RAID0, 2)
+
+    def test_mdraid_raid1(self):
+        self._test_mdraid(blivet.devicelibs.raid.RAID1, 2)
+
+    def test_mdraid_raid5(self):
+        self._test_mdraid(blivet.devicelibs.raid.RAID5, 3)
+
+    def test_mdraid_raid6(self):
+        self._test_mdraid(blivet.devicelibs.raid.RAID6, 4)
+
+    def test_mdraid_raid10(self):
+        self._test_mdraid(blivet.devicelibs.raid.RAID10, 4)
+
+    def test_mdraid_raid0_extra(self):
+        parts = self._prepare_members(2)
+        array = self.storage.new_mdarray(name=self.raidname, parents=parts,
+                                         level=blivet.devicelibs.raid.RAID0,
+                                         total_devices=2,
+                                         member_devices=2,
+                                         chunk_size=blivet.size.Size("1 MiB"),
+                                         metadata_version="1.2")
+        self.storage.create_device(array)
+
+        self.storage.do_it()
+        self.storage.reset()
+
+        array = self.storage.devicetree.get_device_by_name(self.raidname)
+        self.assertIsNotNone(array)
+        self.assertEqual(array.chunk_size, blivet.size.Size("1 MiB"))
+        self.assertEqual(array.metadata_version, "1.2")
+
+    def test_mdraid_raid1_spare(self):
+        parts = self._prepare_members(3)
+        array = self.storage.new_mdarray(name=self.raidname, parents=parts,
+                                         level=blivet.devicelibs.raid.RAID1,
+                                         total_devices=3,
+                                         member_devices=2)
+        self.storage.create_device(array)
+
+        self.storage.do_it()
+        self.storage.reset()
+
+        array = self.storage.devicetree.get_device_by_name(self.raidname)
+        self.assertIsNotNone(array)
+        self.assertEqual(array.level, blivet.devicelibs.raid.RAID1)
+        self.assertEqual(array.total_devices, 3)
+        self.assertEqual(array.member_devices, 2)
+        self.assertEqual(array.spares, 1)
+        self.assertCountEqual([m.name for m in array.members],
+                              [p.name for p in parts])
+        for member in array.members:
+            self.assertEqual(member.format.md_uuid, array.uuid)
+
+    def test_mdraid_members_add_remove(self):
+        parts = self._prepare_members(2)
+        array = self.storage.new_mdarray(name=self.raidname, parents=parts,
+                                         level=blivet.devicelibs.raid.RAID1,
+                                         total_devices=2,
+                                         member_devices=2)
+        self.storage.create_device(array)
+
+        self.storage.do_it()
+        self.storage.reset()
+
+        array = self.storage.devicetree.get_device_by_name(self.raidname)
+        self.assertIsNotNone(array)
+        self.assertEqual(array.level, blivet.devicelibs.raid.RAID1)
+        self.assertEqual(array.total_devices, 2)
+        self.assertEqual(array.member_devices, 2)
+        self.assertEqual(array.spares, 0)
+
+        # add third disk to the array
+        disk = self.storage.devicetree.get_device_by_path(self.vdevs[2])
+        self.assertIsNotNone(disk)
+        self.storage.initialize_disk(disk)
+
+        part = self.storage.new_partition(size=blivet.size.Size("100 MiB"), fmt_type="mdmember",
+                                          parents=[disk])
+        self.storage.create_device(part)
+
+        blivet.partitioning.do_partitioning(self.storage)
+
+        array = self.storage.devicetree.get_device_by_name(self.raidname)
+
+        ac = blivet.deviceaction.ActionAddMember(array, part)
+        self.storage.devicetree.actions.add(ac)
+        self.storage.do_it()
+
+        array = self.storage.devicetree.get_device_by_name(self.raidname)
+        self.assertIsNotNone(array)
+        self.assertEqual(array.level, blivet.devicelibs.raid.RAID1)
+        self.assertEqual(array.total_devices, 3)
+        self.assertEqual(array.member_devices, 3)
+        self.assertEqual(array.spares, 0)
+        self.assertEqual(part.format.md_uuid, array.uuid)
+
+        # and now remove it from the array
+        ac = blivet.deviceaction.ActionRemoveMember(array, part)
+        self.storage.devicetree.actions.add(ac)
+        self.storage.do_it()
+
+        array = self.storage.devicetree.get_device_by_name(self.raidname)
+        self.assertIsNotNone(array)
+        self.assertEqual(array.level, blivet.devicelibs.raid.RAID1)
+        self.assertEqual(array.total_devices, 2)
+        self.assertEqual(array.member_devices, 2)
+        self.assertEqual(array.spares, 0)
+        self.assertFalse(array.degraded)
+        self.assertIsNone(part.format.md_uuid)

tests/storage_tests/storagetestcase.py

@@ -183,7 +183,7 @@ def setUp(self):
         self.vdevs = []
         self._dev_files = []
 
-        for _ in range(2):
+        for _ in range(4):
             dev_file = create_sparse_tempfile("blivet_test", self._disk_size)
             self._dev_files.append(dev_file)
             try: