def test_chunk_size2(self): member1 = StorageDevice("member1", fmt=blivet.formats.get_format("mdmember"), size=Size("1 GiB")) member2 = StorageDevice("member2", fmt=blivet.formats.get_format("mdmember"), size=Size("1 GiB")) raid_array = MDRaidArrayDevice(name="raid", level="raid0", member_devices=2, total_devices=2, parents=[member1, member2], chunk_size=Size("1024 KiB")) self.assertEqual(raid_array.chunk_size, Size("1024 KiB")) with self.assertRaisesRegex(ValueError, "new chunk size must be of type Size"): raid_array.chunk_size = 1 with self.assertRaisesRegex( ValueError, "new chunk size must be multiple of 4 KiB"): raid_array.chunk_size = Size("5 KiB")
def check_completeness_test(self): """Test CheckCompleteness.""" dev1 = StorageDevice("dev1", fmt=get_format("ext4"), size=Size("10 GiB"), exists=True) dev2 = MDRaidArrayDevice(name="dev2", size=Size("500 MiB"), level=1, member_devices=2, total_devices=2, exists=True) dev3 = LVMVolumeGroupDevice("dev3", pv_count=2, exists=True) self._add_device(dev1) self._add_device(dev2) self._add_device(dev3) self._check_report(self.interface.CheckCompleteness("dev1")) self._check_report( self.interface.CheckCompleteness("dev2"), "This Software RAID array is missing 2 of 2 member partitions. " "You can remove it or select a different device.") self._check_report( self.interface.CheckCompleteness("dev3"), "This LVM Volume Group is missing 2 of 2 physical volumes. " "You can remove it or select a different device.") dev1.complete = False self._check_report( self.interface.CheckCompleteness("dev1"), "This blivet device is missing member devices. " "You can remove it or select a different device.")
def generate_device_factory_request_raid_test(self, blockdev): disk1 = DiskDevice("dev1", fmt=get_format("mdmember")) disk2 = DiskDevice("dev2", fmt=get_format("mdmember")) device = MDRaidArrayDevice("dev3", level="raid1", parents=[disk1, disk2]) request = utils.generate_device_factory_request(self.storage, device) self.assertEqual( DeviceFactoryRequest.to_structure(request), { "device-spec": get_variant(Str, "dev3"), "disks": get_variant(List[Str], ["dev1", "dev2"]), "mount-point": get_variant(Str, ""), "reformat": get_variant(Bool, True), "format-type": get_variant(Str, ""), "label": get_variant(Str, ""), "luks-version": get_variant(Str, ""), "device-type": get_variant(Int, devicefactory.DEVICE_TYPE_MD), "device-name": get_variant(Str, "dev3"), "device-size": get_variant(UInt64, 0), "device-encrypted": get_variant(Bool, False), "device-raid-level": get_variant(Str, "raid1"), "container-spec": get_variant(Str, ""), "container-name": get_variant(Str, ""), "container-size-policy": get_variant(Int64, 0), "container-encrypted": get_variant(Bool, False), "container-raid-level": get_variant(Str, ""), })
def test_chunk_size2(self): member1 = StorageDevice("member1", fmt=blivet.formats.get_format("mdmember"), size=Size("1 GiB")) member2 = StorageDevice("member2", fmt=blivet.formats.get_format("mdmember"), size=Size("1 GiB")) raid_array = MDRaidArrayDevice(name="raid", level="raid0", member_devices=2, total_devices=2, parents=[member1, member2], chunk_size=Size("1024 KiB")) self.assertEqual(raid_array.chunk_size, Size("1024 KiB")) with six.assertRaisesRegex(self, ValueError, "new chunk size must be of type Size"): raid_array.chunk_size = 1 with six.assertRaisesRegex(self, ValueError, "new chunk size must be multiple of 4 KiB"): raid_array.chunk_size = Size("5 KiB")
def setUp(self): dev1 = DiskDevice("name", fmt=getFormat("mdmember")) dev2 = DiskDevice("other") self.part = PartitionDevice("part", fmt=getFormat("mdmember"), parents=[dev2]) self.dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1, self.part], fmt=getFormat("luks")) self.luks = LUKSDevice("luks", parents=[self.dev], fmt=getFormat("ext4")) self.mdraid_method = availability.BLOCKDEV_MDRAID_PLUGIN._method self.dm_method = availability.BLOCKDEV_DM_PLUGIN._method self.cache_availability = availability.CACHE_AVAILABILITY
def setUp(self): """Create some device objects to test with. This sets up two disks (sda, sdb). The first partition of each is a biosboot partition. The second partitions comprise a RAID1 array formatted as /boot. sda additionally contains a third partition formatted as ext4. """ super(GRUBRaidSimpleTest, self).setUp() # Make some disks self.sda = DiskDevice(name="sda", size=Size("100 GiB")) self.sda.format = getFormat("disklabel") self.sdb = DiskDevice(name="sdb", size=Size("100 GiB")) self.sdb.format = getFormat("disklabel") # Set up biosboot partitions and an array for /boot on sda + sdb. # Start with the partitions self.sda1 = PartitionDevice(name="sda1", parents=[self.sda], size=Size("1 MiB")) self.sda1.format = getFormat("biosboot") self.sda2 = PartitionDevice(name="sda2", parents=[self.sda], size=Size("500 MiB")) self.sda2.format = getFormat("mdmember") self.sdb1 = PartitionDevice(name="sdb1", parents=[self.sdb], size=Size("1 MiB")) self.sdb1.format = getFormat("biosboot") self.sdb2 = PartitionDevice(name="sdb2", parents=[self.sdb], size=Size("500 MiB")) self.sdb2.format = getFormat("mdmember") # Add an extra partition for /boot on not-RAID self.sda3 = PartitionDevice(name="sda3", parents=[self.sda], size=Size("500 MiB")) self.sda3.format = getFormat("ext4", mountpoint="/boot") # Pretend that the partitions are real with real parent disks for part in (self.sda1, self.sda2, self.sdb1, self.sdb2): part.parents = part.req_disks self.boot_md = MDRaidArrayDevice(name="md1", parents=[self.sda2, self.sdb2], level=1) self.boot_md.format = getFormat("ext4", mountpoint="/boot") self.grub = GRUB()
def test_dependencies(self): dev1 = DiskDevice("name", fmt=get_format("mdmember")) dev2 = DiskDevice("other", fmt=get_format("mdmember")) dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1, dev2]) luks = LUKSDevice("luks", parents=[dev]) # a parent's dependencies are a subset of its child's. for d in dev.external_dependencies: self.assertIn(d, luks.external_dependencies) # make sure that there's at least something in these dependencies self.assertGreater(len(luks.external_dependencies), 0)
def test_chunk_size1(self): member1 = StorageDevice("member1", fmt=blivet.formats.get_format("mdmember"), size=Size("1 GiB")) member2 = StorageDevice("member2", fmt=blivet.formats.get_format("mdmember"), size=Size("1 GiB")) raid_array = MDRaidArrayDevice(name="raid", level="raid0", member_devices=2, total_devices=2, parents=[member1, member2]) # no chunk_size specified -- default value self.assertEqual(raid_array.chunk_size, mdraid.MD_CHUNK_SIZE)
def test_packages(self): dev1 = DiskDevice("name", fmt=get_format("mdmember")) dev2 = DiskDevice("other", fmt=get_format("mdmember")) dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1, dev2]) luks = LUKSDevice("luks", parents=[dev]) packages = luks.packages # no duplicates in list of packages self.assertEqual(len(packages), len(set(packages))) # several packages that ought to be included are for package in dev1.packages + dev2.packages + dev.packages: self.assertIn(package, packages) for package in dev1.format.packages + dev2.format.packages + dev.format.packages: self.assertIn(package, packages)
def setUp(self): dev1 = DiskDevice("name", fmt=get_format("mdmember"), size=Size("1 GiB")) dev2 = DiskDevice("other") self.part = PartitionDevice("part", fmt=get_format("mdmember"), parents=[dev2]) self.dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1, self.part], fmt=get_format("luks"), total_devices=2, member_devices=2) self.luks = LUKSDevice("luks", parents=[self.dev], fmt=get_format("ext4")) self.mdraid_method = availability.BLOCKDEV_MDRAID_PLUGIN._method self.dm_method = availability.BLOCKDEV_DM_PLUGIN._method self.hfsplus_method = availability.MKFS_HFSPLUS_APP._method self.cache_availability = availability.CACHE_AVAILABILITY self.addCleanup(self._clean_up)
def testMDRaidArrayDeviceInit(self): """Tests the state of a MDRaidArrayDevice after initialization. For some combinations of arguments the initializer will throw an exception. """ ## ## level tests ## self.stateCheck(self.dev1, devices=xform(lambda x, m: self.assertEqual(len(x), 1, m)), level=xform(lambda x, m: self.assertEqual(x.name, "container", m)), parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)), mediaPresent=xform(self.assertFalse), type=xform(lambda x, m: self.assertEqual(x, "mdcontainer", m))) self.stateCheck(self.dev2, createBitmap=xform(self.assertFalse), devices=xform(lambda x, m: self.assertEqual(len(x), 2, m)), level=xform(lambda x, m: self.assertEqual(x.number, 0, m)), parents=xform(lambda x, m: self.assertEqual(len(x), 2, m))) self.stateCheck(self.dev3, devices=xform(lambda x, m: self.assertEqual(len(x), 2, m)), level=xform(lambda x, m: self.assertEqual(x.number, 1, m)), parents=xform(lambda x, m: self.assertEqual(len(x), 2, m))) self.stateCheck(self.dev4, devices=xform(lambda x, m: self.assertEqual(len(x), 3, m)), level=xform(lambda x, m: self.assertEqual(x.number, 4, m)), parents=xform(lambda x, m: self.assertEqual(len(x), 3, m))) self.stateCheck(self.dev5, devices=xform(lambda x, m: self.assertEqual(len(x), 3, m)), level=xform(lambda x, m: self.assertEqual(x.number, 5, m)), parents=xform(lambda x, m: self.assertEqual(len(x), 3, m))) self.stateCheck(self.dev6, devices=xform(lambda x, m: self.assertEqual(len(x), 4, m)), level=xform(lambda x, m: self.assertEqual(x.number, 6, m)), parents=xform(lambda x, m: self.assertEqual(len(x), 4, m))) self.stateCheck(self.dev7, devices=xform(lambda x, m: self.assertEqual(len(x), 4, m)), level=xform(lambda x, m: self.assertEqual(x.number, 10, m)), parents=xform(lambda x, m: self.assertEqual(len(x), 4, m))) ## ## existing device tests ## self.stateCheck(self.dev8, exists=xform(self.assertTrue), level=xform(lambda x, m: self.assertEqual(x.number, 1, m)), metadataVersion=xform(self.assertIsNone)) ## ## mdbiosraidarray tests ## self.stateCheck(self.dev9, createBitmap=xform(self.assertFalse), devices=xform(lambda x, m: self.assertEqual(len(x), 2, m)), isDisk=xform(self.assertTrue), level=xform(lambda x, m: self.assertEqual(x.number, 0, m)), memberDevices=xform(lambda x, m: self.assertEqual(x, 2, m)), parents=xform(lambda x, m: self.assertNotEqual(x, [], m)), partitionable=xform(self.assertTrue), totalDevices=xform(lambda x, m: self.assertEqual(x, 2, m)), type = xform(lambda x, m: self.assertEqual(x, "mdbiosraidarray", m))) ## ## size tests ## self.stateCheck(self.dev10, createBitmap=xform(self.assertFalse), devices=xform(lambda x, m: self.assertEqual(len(x), 2, m)), level=xform(lambda x, m: self.assertEqual(x.number, 0, m)), parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)), targetSize=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m))) self.stateCheck(self.dev11, devices=xform(lambda x, m: self.assertEqual(len(x), 2, m)), isDisk=xform(self.assertTrue), level=xform(lambda x, m: self.assertEqual(x.number, 1, m)), memberDevices=xform(lambda x, m: self.assertEqual(x, 2, m)), parents=xform(lambda x, m: self.assertNotEqual(x, [], m)), partitionable=xform(self.assertTrue), targetSize=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)), totalDevices=xform(lambda x, m: self.assertEqual(x, 2, m)), type=xform(lambda x, m: self.assertEqual(x, "mdbiosraidarray", m))) self.stateCheck(self.dev12, devices=xform(lambda x, m: self.assertEqual(len(x), 2, m)), isDisk=xform(self.assertTrue), level=xform(lambda x, m: self.assertEqual(x.number, 1, m)), memberDevices=xform(lambda x, m: self.assertEqual(x, 2, m)), parents=xform(lambda x, m: self.assertNotEqual(x, [], m)), partitionable=xform(self.assertTrue), targetSize=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)), totalDevices=xform(lambda x, m: self.assertEqual(x, 2, m)), type = xform(lambda x, m: self.assertEqual(x, "mdbiosraidarray", m))) self.stateCheck(self.dev13, createBitmap=xform(self.assertFalse), devices=xform(lambda x, m: self.assertEqual(len(x), 2, m)), level=xform(lambda x, m: self.assertEqual(x.number, 0, m)), memberDevices=xform(lambda x, m: self.assertEqual(x, 3, m)), parents=xform(lambda x, m: self.assertNotEqual(x, [], m)), size=xform(lambda x, m: self.assertEqual(x, Size("3 MiB"), m)), targetSize=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)), totalDevices=xform(lambda x, m: self.assertEqual(x, 3, m))) self.stateCheck(self.dev14, createBitmap=xform(self.assertTrue), devices=xform(lambda x, m: self.assertEqual(len(x), 3, m)), level=xform(lambda x, m: self.assertEqual(x.number, 4, m)), memberDevices=xform(lambda x, m: self.assertEqual(x, 3, m)), parents=xform(lambda x, m: self.assertNotEqual(x, [], m)), size=xform(lambda x, m: self.assertEqual(x, Size("2 MiB"), m)), totalDevices=xform(lambda x, m: self.assertEqual(x, 3, m))) self.stateCheck(self.dev15, createBitmap=xform(self.assertTrue), devices=xform(lambda x, m: self.assertEqual(len(x), 3, m)), level=xform(lambda x, m: self.assertEqual(x.number, 5, m)), memberDevices=xform(lambda x, m: self.assertEqual(x, 3, m)), parents=xform(lambda x, m: self.assertNotEqual(x, [], m)), size=xform(lambda x, m: self.assertEqual(x, Size("2 MiB"), m)), totalDevices=xform(lambda x, m: self.assertEqual(x, 3, m))) self.stateCheck(self.dev16, createBitmap=xform(self.assertTrue), devices=xform(lambda x, m: self.assertEqual(len(x), 4, m)), level=xform(lambda x, m: self.assertEqual(x.number, 6, m)), memberDevices=xform(lambda x, m: self.assertEqual(x, 4, m)), parents=xform(lambda x, m: self.assertNotEqual(x, [], m)), size=xform(lambda x, m: self.assertEqual(x, Size("2 MiB"), m)), totalDevices=xform(lambda x, m: self.assertEqual(x, 4, m))) self.stateCheck(self.dev17, createBitmap=xform(self.assertTrue), devices=xform(lambda x, m: self.assertEqual(len(x), 4, m)), level=xform(lambda x, m: self.assertEqual(x.number, 10, m)), memberDevices=xform(lambda x, m: self.assertEqual(x, 4, m)), parents=xform(lambda x, m: self.assertNotEqual(x, [], m)), size=xform(lambda x, m: self.assertEqual(x, Size("2 MiB"), m)), totalDevices=xform(lambda x, m: self.assertEqual(x, 4, m))) self.stateCheck(self.dev18, createBitmap=xform(self.assertTrue), devices=xform(lambda x, m: self.assertEqual(len(x), 4, m)), level=xform(lambda x, m: self.assertEqual(x.number, 10, m)), memberDevices=xform(lambda x, m: self.assertEqual(x, 4, m)), parents=xform(lambda x, m: self.assertNotEqual(x, [], m)), size=xform(lambda x, m: self.assertEqual(x, Size("2 MiB"), m)), spares=xform(lambda x, m: self.assertEqual(x, 1, m)), totalDevices=xform(lambda x, m: self.assertEqual(x, 5, m))) self.stateCheck(self.dev19, devices=xform(lambda x, m: self.assertEqual(len(x), 2, m)), level=xform(lambda x, m: self.assertEqual(x.number, 1, m)), mdadmFormatUUID=xform(lambda x, m: self.assertEqual(x, blockdev.md.get_md_uuid(self.dev19.uuid), m)), parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)), uuid=xform(lambda x, m: self.assertEqual(x, self.dev19.uuid, m))) self.stateCheck(self.dev20, devices=xform(lambda x, m: self.assertEqual(len(x), 2, m)), level=xform(lambda x, m: self.assertEqual(x.number, 1, m)), parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)), uuid=xform(lambda x, m: self.assertEqual(x, self.dev20.uuid, m))) with self.assertRaisesRegex(DeviceError, "invalid"): MDRaidArrayDevice("dev") with self.assertRaisesRegex(DeviceError, "invalid"): MDRaidArrayDevice("dev", level="raid2") with self.assertRaisesRegex(DeviceError, "invalid"): MDRaidArrayDevice( "dev", parents=[StorageDevice("parent", fmt=getFormat("mdmember"))]) with self.assertRaisesRegex(DeviceError, "at least 2 members"): MDRaidArrayDevice( "dev", level="raid0", parents=[StorageDevice("parent", fmt=getFormat("mdmember"))]) with self.assertRaisesRegex(DeviceError, "invalid"): MDRaidArrayDevice("dev", level="junk") with self.assertRaisesRegex(DeviceError, "at least 2 members"): MDRaidArrayDevice("dev", level=0, memberDevices=2)
def setUp(self): self._state_functions = { "createBitmap": self.assertTrue, "currentSize": lambda x, m: self.assertEqual(x, Size(bytes=0), m), "description": self.assertIsNotNone, "devices": lambda x, m: self.assertEqual(len( x), 0, m) and self.assertIsInstance(x, ParentList, m), "exists": self.assertFalse, "format": self.assertIsNotNone, "formatArgs": lambda x, m: self.assertEqual(x, [], m), "formatClass": self.assertIsNotNone, "isDisk": self.assertFalse, "level": self.assertIsNone, "major": lambda x, m: self.assertEqual(x, 0, m), "maxSize": lambda x, m: self.assertEqual(x, Size(bytes=0), m), "mediaPresent": self.assertFalse, "metadataVersion": lambda x, m: self.assertEqual(x, "default", m), "minor": lambda x, m: self.assertEqual(x, 0, m), "parents": lambda x, m: self.assertEqual(len(x), 0, m) and self. assertIsInstance(x, ParentList, m), "path": lambda x, m: self.assertRegexpMatches(x, "^/dev", m), "partitionable": self.assertFalse, "rawArraySize": lambda x, m: self.assertEqual(x, Size(bytes=0), m), "resizable": self.assertFalse, "size": lambda x, m: self.assertEqual(x, Size(bytes=0), m), "smallestMember": self.assertIsNone, "spares": lambda x, m: self.assertEqual(x, 0, m), "status": self.assertFalse, "superBlockSize": lambda x, m: self.assertEqual(x, Size(spec="1 MiB"), m), "sysfsPath": lambda x, m: self.assertEqual(x, "", m), "targetSize": lambda x, m: self.assertEqual(x, Size(bytes=0), m), "uuid": self.assertIsNone, "memberDevices": lambda x, m: self.assertEqual(x, 0, m), "totalDevices": lambda x, m: self.assertEqual(x, 0, m), "type": lambda x, m: self.assertEqual(x, "mdarray", m) } self.dev1 = MDRaidArrayDevice("dev1", level="container") self.dev2 = MDRaidArrayDevice("dev2", level="raid0") self.dev3 = MDRaidArrayDevice("dev3", level="raid1") self.dev4 = MDRaidArrayDevice("dev4", level="raid4") self.dev5 = MDRaidArrayDevice("dev5", level="raid5") self.dev6 = MDRaidArrayDevice("dev6", level="raid6") self.dev7 = MDRaidArrayDevice("dev7", level="raid10") self.dev8 = MDRaidArrayDevice("dev8", level=1, exists=True) self.dev9 = MDRaidArrayDevice( "dev9", level="raid0", memberDevices=2, parents=[ MDRaidArrayDevice("parent", level="container", format=getFormat("mdmember")), MDRaidArrayDevice("other", level=0, format=getFormat("mdmember")) ], totalDevices=2) self.dev10 = MDRaidArrayDevice("dev10", level="raid0", size=Size(spec="32 MiB")) self.dev11 = MDRaidArrayDevice( "dev11", level=1, memberDevices=2, parents=[ MDRaidArrayDevice("parent", level="container", format=getFormat("mdmember")), MDRaidArrayDevice("other", level="raid0", format=getFormat("mdmember")) ], size=Size(spec="32 MiB"), totalDevices=2) self.dev12 = MDRaidArrayDevice( "dev12", level=1, memberDevices=2, parents=[ Mock( **{ "type": "mdcontainer", "size": Size(spec="4 MiB"), "format": getFormat("mdmember") }), Mock(**{ "size": Size(spec="2 MiB"), "format": getFormat("mdmember") }) ], size=Size(spec="32 MiB"), totalDevices=2) self.dev13 = MDRaidArrayDevice( "dev13", level=0, memberDevices=3, parents=[ Mock(**{ "size": Size(spec="4 MiB"), "format": getFormat("mdmember") }), Mock(**{ "size": Size(spec="2 MiB"), "format": getFormat("mdmember") }) ], size=Size(spec="32 MiB"), totalDevices=3) self.dev14 = MDRaidArrayDevice( "dev14", level=4, memberDevices=3, parents=[ Mock(**{ "size": Size(spec="4 MiB"), "format": getFormat("mdmember") }), Mock(**{ "size": Size(spec="2 MiB"), "format": getFormat("mdmember") }), Mock(**{ "size": Size(spec="2 MiB"), "format": getFormat("mdmember") }) ], totalDevices=3) self.dev15 = MDRaidArrayDevice( "dev15", level=5, memberDevices=3, parents=[ Mock(**{ "size": Size(spec="4 MiB"), "format": getFormat("mdmember") }), Mock(**{ "size": Size(spec="2 MiB"), "format": getFormat("mdmember") }), Mock(**{ "size": Size(spec="2 MiB"), "format": getFormat("mdmember") }) ], totalDevices=3) self.dev16 = MDRaidArrayDevice( "dev16", level=6, memberDevices=4, parents=[ Mock(**{ "size": Size(spec="4 MiB"), "format": getFormat("mdmember") }), Mock(**{ "size": Size(spec="4 MiB"), "format": getFormat("mdmember") }), Mock(**{ "size": Size(spec="2 MiB"), "format": getFormat("mdmember") }), Mock(**{ "size": Size(spec="2 MiB"), "format": getFormat("mdmember") }) ], totalDevices=4) self.dev17 = MDRaidArrayDevice( "dev17", level=10, memberDevices=4, parents=[ Mock(**{ "size": Size(spec="4 MiB"), "format": getFormat("mdmember") }), Mock(**{ "size": Size(spec="4 MiB"), "format": getFormat("mdmember") }), Mock(**{ "size": Size(spec="2 MiB"), "format": getFormat("mdmember") }), Mock(**{ "size": Size(spec="2 MiB"), "format": getFormat("mdmember") }) ], totalDevices=4) self.dev18 = MDRaidArrayDevice( "dev18", level=10, memberDevices=4, parents=[ Mock(**{ "size": Size(spec="4 MiB"), "format": getFormat("mdmember") }), Mock(**{ "size": Size(spec="4 MiB"), "format": getFormat("mdmember") }), Mock(**{ "size": Size(spec="2 MiB"), "format": getFormat("mdmember") }), Mock(**{ "size": Size(spec="2 MiB"), "format": getFormat("mdmember") }) ], totalDevices=5)
def setUp(self): """Create some device objects to test with. This sets up two disks (sda, sdb). The first partition of each is a biosboot partition. The second partitions comprise a RAID1 array formatted as /boot. sda additionally contains a third partition formatted as ext4. """ super(GRUBRaidSimpleTest, self).setUp() # Make some disks self.sda = DiskDevice(name="sda", size=Size("100 GiB")) self.sda.format = get_format("disklabel") self.sdb = DiskDevice(name="sdb", size=Size("100 GiB")) self.sdb.format = get_format("disklabel") # Set up biosboot partitions, an mdarray for /boot, and a btrfs array on sda + sdb. # Start with the partitions self.sda1 = PartitionDevice(name="sda1", parents=[self.sda], size=Size("1 MiB")) self.sda1.format = get_format("biosboot") self.sda2 = PartitionDevice(name="sda2", parents=[self.sda], size=Size("500 MiB")) self.sda2.format = get_format("mdmember") self.sda4 = PartitionDevice(name="sda4", parents=[self.sda], size=Size("500 MiB")) self.sda4.format = get_format("btrfs") self.sdb1 = PartitionDevice(name="sdb1", parents=[self.sdb], size=Size("1 MiB")) self.sdb1.format = get_format("biosboot") self.sdb2 = PartitionDevice(name="sdb2", parents=[self.sdb], size=Size("500 MiB")) self.sdb2.format = get_format("mdmember") self.sdb4 = PartitionDevice(name="sdb4", parents=[self.sdb], size=Size("4 GiB")) self.sdb4.format = get_format("btrfs") # Add an extra partition for /boot on not-RAID self.sda3 = PartitionDevice(name="sda3", parents=[self.sda], size=Size("500 MiB")) self.sda3.format = get_format("ext4", mountpoint="/boot") # Pretend that the partitions are real with real parent disks for part in (self.sda1, self.sda2, self.sda3, self.sda4, self.sdb1, self.sdb2, self.sdb4): part.parents = part.req_disks self.boot_md = MDRaidArrayDevice(name="md1", size=Size("500 MiB"), parents=[self.sda2, self.sdb2], level=1, member_devices=2, total_devices=2) self.boot_md.format = get_format("ext4", mountpoint="/boot") # Set up the btrfs raid1 volume with a subvolume for /boot self.btrfs_volume = BTRFSVolumeDevice(parents=[self.sda4, self.sdb4], data_level=RAID1) self.btrfs_volume.format = get_format("btrfs") self.boot_btrfs = BTRFSSubVolumeDevice(parents=[self.btrfs_volume]) self.boot_btrfs.format = get_format("btrfs", mountpoint="/boot") self.grub = GRUB2()
def test_mdraid_array_device_init(self): """Tests the state of a MDRaidArrayDevice after initialization. For some combinations of arguments the initializer will throw an exception. """ ## # level tests ## self.state_check( self.dev1, level=xform(lambda x, m: self.assertEqual(x.name, "container", m)), parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)), member_devices=xform(lambda x, m: self.assertEqual(x, 1, m)), members=xform(lambda x, m: self.assertEqual(len(x), 1, m)), media_present=xform(self.assertFalse), total_devices=xform(lambda x, m: self.assertEqual(x, 1, m)), type=xform(lambda x, m: self.assertEqual(x, "mdcontainer", m))) self.state_check( self.dev2, create_bitmap=xform(self.assertFalse), level=xform(lambda x, m: self.assertEqual(x.number, 0, m)), member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)), members=xform(lambda x, m: self.assertEqual(len(x), 2, m)), size=xform(lambda x, m: self.assertEqual(x, Size("2 GiB"), m)), parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)), total_devices=xform(lambda x, m: self.assertEqual(x, 2, m))) self.state_check( self.dev3, level=xform(lambda x, m: self.assertEqual(x.number, 1, m)), members=xform(lambda x, m: self.assertEqual(len(x), 2, m)), parents=xform(lambda x, m: self.assertEqual(len(x), 2, m))) self.state_check( self.dev4, level=xform(lambda x, m: self.assertEqual(x.number, 4, m)), members=xform(lambda x, m: self.assertEqual(len(x), 3, m)), parents=xform(lambda x, m: self.assertEqual(len(x), 3, m))) self.state_check( self.dev5, level=xform(lambda x, m: self.assertEqual(x.number, 5, m)), members=xform(lambda x, m: self.assertEqual(len(x), 3, m)), parents=xform(lambda x, m: self.assertEqual(len(x), 3, m))) self.state_check( self.dev6, level=xform(lambda x, m: self.assertEqual(x.number, 6, m)), members=xform(lambda x, m: self.assertEqual(len(x), 4, m)), parents=xform(lambda x, m: self.assertEqual(len(x), 4, m))) self.state_check( self.dev7, level=xform(lambda x, m: self.assertEqual(x.number, 10, m)), members=xform(lambda x, m: self.assertEqual(len(x), 4, m)), parents=xform(lambda x, m: self.assertEqual(len(x), 4, m))) ## # existing device tests ## self.state_check( self.dev8, exists=xform(self.assertTrue), level=xform(lambda x, m: self.assertEqual(x.number, 1, m)), metadata_version=xform(self.assertIsNone)) ## # mdbiosraidarray tests ## self.state_check( self.dev9, create_bitmap=xform(self.assertFalse), is_disk=xform(self.assertTrue), exists=xform(self.assertTrue), level=xform(lambda x, m: self.assertEqual(x.number, 0, m)), member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)), members=xform(lambda x, m: self.assertEqual(len(x), 2, m)), metadata_version=xform(lambda x, m: self.assertEqual(x, None, m)), parents=xform(lambda x, m: self.assertEqual(len(x), 1, m)), partitionable=xform(self.assertTrue), total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)), type=xform(lambda x, m: self.assertEqual(x, "mdbiosraidarray", m))) ## # mdcontainer tests ## dev9_container = self.dev9.parents[0] self.state_check( dev9_container, create_bitmap=xform(self.assertFalse), direct=xform(self.assertFalse), is_disk=xform(self.assertFalse), isleaf=xform(self.assertFalse), exists=xform(self.assertTrue), level=xform(lambda x, m: self.assertEqual(x.name, "container", m)), media_present=xform(self.assertFalse), member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)), members=xform(lambda x, m: self.assertEqual(len(x), 2, m)), metadata_version=xform(lambda x, m: self.assertEqual(x, None, m)), parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)), partitionable=xform(self.assertFalse), total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)), type=xform(lambda x, m: self.assertEqual(x, "mdcontainer", m))) ## # size tests ## self.state_check( self.dev10, create_bitmap=xform(self.assertFalse), level=xform(lambda x, m: self.assertEqual(x.number, 0, m)), members=xform(lambda x, m: self.assertEqual(len(x), 2, m)), parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)), target_size=xform( lambda x, m: self.assertEqual(x, Size("32 MiB"), m))) self.state_check( self.dev11, is_disk=xform(self.assertTrue), exists=xform(lambda x, m: self.assertEqual(x, True, m)), level=xform(lambda x, m: self.assertEqual(x.number, 1, m)), current_size=xform( lambda x, m: self.assertEqual(x, Size("32 MiB"), m)), max_size=xform( lambda x, m: self.assertEqual(x, Size("32 MiB"), m)), member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)), members=xform(lambda x, m: self.assertEqual(len(x), 2, m)), metadata_version=xform(lambda x, m: self.assertEqual(x, None, m)), parents=xform(lambda x, m: self.assertNotEqual(x, [], m)), partitionable=xform(self.assertTrue), size=xform(lambda x, m: self.assertEqual(x, Size("32 MiB"), m)), target_size=xform( lambda x, m: self.assertEqual(x, Size("32 MiB"), m)), total_devices=xform(lambda x, m: self.assertEqual(x, 2, m)), type=xform(lambda x, m: self.assertEqual(x, "mdbiosraidarray", m))) self.state_check( self.dev13, create_bitmap=xform(self.assertFalse), level=xform(lambda x, m: self.assertEqual(x.number, 0, m)), member_devices=xform(lambda x, m: self.assertEqual(x, 2, m)), members=xform(lambda x, m: self.assertEqual(len(x), 2, m)), parents=xform(lambda x, m: self.assertNotEqual(x, [], m)), size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)), target_size=xform( lambda x, m: self.assertEqual(x, Size("32 MiB"), m)), total_devices=xform(lambda x, m: self.assertEqual(x, 2, m))) self.state_check( self.dev14, create_bitmap=xform(self.assertTrue), level=xform(lambda x, m: self.assertEqual(x.number, 4, m)), member_devices=xform(lambda x, m: self.assertEqual(x, 3, m)), members=xform(lambda x, m: self.assertEqual(len(x), 3, m)), parents=xform(lambda x, m: self.assertNotEqual(x, [], m)), size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)), total_devices=xform(lambda x, m: self.assertEqual(x, 3, m))) self.state_check( self.dev15, create_bitmap=xform(self.assertTrue), level=xform(lambda x, m: self.assertEqual(x.number, 5, m)), member_devices=xform(lambda x, m: self.assertEqual(x, 3, m)), members=xform(lambda x, m: self.assertEqual(len(x), 3, m)), parents=xform(lambda x, m: self.assertNotEqual(x, [], m)), size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)), total_devices=xform(lambda x, m: self.assertEqual(x, 3, m))) self.state_check( self.dev16, create_bitmap=xform(self.assertTrue), level=xform(lambda x, m: self.assertEqual(x.number, 6, m)), member_devices=xform(lambda x, m: self.assertEqual(x, 4, m)), members=xform(lambda x, m: self.assertEqual(len(x), 4, m)), parents=xform(lambda x, m: self.assertNotEqual(x, [], m)), size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)), total_devices=xform(lambda x, m: self.assertEqual(x, 4, m))) self.state_check( self.dev17, create_bitmap=xform(self.assertTrue), level=xform(lambda x, m: self.assertEqual(x.number, 10, m)), member_devices=xform(lambda x, m: self.assertEqual(x, 4, m)), members=xform(lambda x, m: self.assertEqual(len(x), 4, m)), parents=xform(lambda x, m: self.assertNotEqual(x, [], m)), size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)), total_devices=xform(lambda x, m: self.assertEqual(x, 4, m))) self.state_check( self.dev18, create_bitmap=xform(self.assertTrue), level=xform(lambda x, m: self.assertEqual(x.number, 10, m)), member_devices=xform(lambda x, m: self.assertEqual(x, 4, m)), members=xform(lambda x, m: self.assertEqual(len(x), 4, m)), parents=xform(lambda x, m: self.assertNotEqual(x, [], m)), size=xform(lambda x, m: self.assertEqual(x, Size("4 MiB"), m)), spares=xform(lambda x, m: self.assertEqual(x, 1, m)), total_devices=xform(lambda x, m: self.assertEqual(x, 5, m))) self.state_check( self.dev19, level=xform(lambda x, m: self.assertEqual(x.number, 1, m)), mdadm_format_uuid=xform(lambda x, m: self.assertEqual( x, blockdev.md.get_md_uuid(self.dev19.uuid), m)), members=xform(lambda x, m: self.assertEqual(len(x), 2, m)), parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)), uuid=xform(lambda x, m: self.assertEqual(x, self.dev19.uuid, m))) self.state_check( self.dev20, level=xform(lambda x, m: self.assertEqual(x.number, 1, m)), members=xform(lambda x, m: self.assertEqual(len(x), 2, m)), parents=xform(lambda x, m: self.assertEqual(len(x), 2, m)), uuid=xform(lambda x, m: self.assertEqual(x, self.dev20.uuid, m))) with six.assertRaisesRegex(self, DeviceError, "invalid"): MDRaidArrayDevice("dev") with six.assertRaisesRegex(self, DeviceError, "invalid"): MDRaidArrayDevice("dev", level="raid2") with six.assertRaisesRegex(self, DeviceError, "invalid"): MDRaidArrayDevice( "dev", parents=[StorageDevice("parent", fmt=get_format("mdmember"))]) with six.assertRaisesRegex(self, DeviceError, "at least 2 members"): MDRaidArrayDevice( "dev", level="raid0", parents=[StorageDevice("parent", fmt=get_format("mdmember"))]) with six.assertRaisesRegex(self, DeviceError, "invalid"): MDRaidArrayDevice("dev", level="junk") with six.assertRaisesRegex(self, DeviceError, "at least 2 members"): MDRaidArrayDevice("dev", level=0, member_devices=2)
def setUp(self): self.md_chunk_size = mdraid.MD_CHUNK_SIZE mdraid.MD_CHUNK_SIZE = Size("1 MiB") self.get_superblock_size = MDRaidArrayDevice.get_superblock_size MDRaidArrayDevice.get_superblock_size = lambda a, s: Size(0) self.addCleanup(self._clean_up) parents = [DiskDevice("name1", fmt=get_format("mdmember"))] self.dev1 = MDContainerDevice("dev1", level="container", parents=parents, total_devices=1, member_devices=1) parents = [ DiskDevice("name1", fmt=get_format("mdmember"), size=Size("1 GiB")), DiskDevice("name2", fmt=get_format("mdmember"), size=Size("1 GiB")) ] self.dev2 = MDRaidArrayDevice("dev2", level="raid0", parents=parents, total_devices=2, member_devices=2) parents = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")) ] self.dev3 = MDRaidArrayDevice("dev3", level="raid1", parents=parents) parents = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")), DiskDevice("name3", fmt=get_format("mdmember")) ] self.dev4 = MDRaidArrayDevice("dev4", level="raid4", parents=parents) parents = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")), DiskDevice("name3", fmt=get_format("mdmember")) ] self.dev5 = MDRaidArrayDevice("dev5", level="raid5", parents=parents) parents = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")), DiskDevice("name3", fmt=get_format("mdmember")), DiskDevice("name4", fmt=get_format("mdmember")) ] self.dev6 = MDRaidArrayDevice("dev6", level="raid6", parents=parents) parents = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")), DiskDevice("name3", fmt=get_format("mdmember")), DiskDevice("name4", fmt=get_format("mdmember")) ] self.dev7 = MDRaidArrayDevice("dev7", level="raid10", parents=parents) self.dev8 = MDRaidArrayDevice("dev8", level=1, exists=True) parents_1 = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")) ] dev_1 = MDContainerDevice("parent", level="container", parents=parents_1, total_devices=2, member_devices=2, exists=True) self.dev9 = MDBiosRaidArrayDevice("dev9", level="raid0", member_devices=1, parents=[dev_1], total_devices=1, exists=True) parents = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")) ] self.dev10 = MDRaidArrayDevice("dev10", level="raid0", parents=parents, size=Size("32 MiB")) parents_1 = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")) ] dev_1 = MDContainerDevice("parent", level="container", parents=parents, total_devices=2, member_devices=2) self.dev11 = MDBiosRaidArrayDevice("dev11", level=1, exists=True, parents=[dev_1], size=Size("32 MiB")) self.dev13 = MDRaidArrayDevice( "dev13", level=0, member_devices=2, parents=[ Mock(**{ "size": Size("4 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }) ], size=Size("32 MiB"), total_devices=2) self.dev14 = MDRaidArrayDevice( "dev14", level=4, member_devices=3, parents=[ Mock(**{ "size": Size("4 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }) ], total_devices=3) self.dev15 = MDRaidArrayDevice( "dev15", level=5, member_devices=3, parents=[ Mock(**{ "size": Size("4 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }) ], total_devices=3) self.dev16 = MDRaidArrayDevice( "dev16", level=6, member_devices=4, parents=[ Mock(**{ "size": Size("4 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("4 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }) ], total_devices=4) self.dev17 = MDRaidArrayDevice( "dev17", level=10, member_devices=4, parents=[ Mock(**{ "size": Size("4 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("4 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }) ], total_devices=4) self.dev18 = MDRaidArrayDevice( "dev18", level=10, member_devices=4, parents=[ Mock(**{ "size": Size("4 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("4 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }), Mock(**{ "size": Size("2 MiB"), "format": get_format("mdmember") }) ], total_devices=5) parents = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")) ] self.dev19 = MDRaidArrayDevice( "dev19", level="raid1", parents=parents, uuid='3386ff85-f501-2621-4a43-5f061eb47236') parents = [ DiskDevice("name1", fmt=get_format("mdmember")), DiskDevice("name2", fmt=get_format("mdmember")) ] self.dev20 = MDRaidArrayDevice("dev20", level="raid1", parents=parents, uuid='Just-pretending')
def add_device(self, user_input): """ Create new device :param user_input: selected parameters from AddDialog :type user_input: class UserInput :returns: new device name :rtype: str """ actions = [] if user_input.device_type == "partition": if user_input.encrypt: dev = PartitionDevice( name="req%d" % self.storage.nextID, size=user_input.size, parents=[i[0] for i in user_input.parents]) actions.append(blivet.deviceaction.ActionCreateDevice(dev)) fmt = blivet.formats.getFormat( fmt_type="luks", passphrase=user_input.passphrase, device=dev.path) actions.append(blivet.deviceaction.ActionCreateFormat( dev, fmt)) luks_dev = LUKSDevice("luks-%s" % dev.name, fmt=blivet.formats.getFormat( user_input.filesystem, device=dev.path, mountpoint=user_input.mountpoint), size=dev.size, parents=[dev]) actions.append( blivet.deviceaction.ActionCreateDevice(luks_dev)) else: new_part = PartitionDevice( name="req%d" % self.storage.nextID, size=user_input.size, parents=[i[0] for i in user_input.parents], partType=PARTITION_TYPE[user_input.advanced["parttype"]]) actions.append( blivet.deviceaction.ActionCreateDevice(new_part)) if user_input.advanced["parttype"] != "extended": new_fmt = blivet.formats.getFormat( fmt_type=user_input.filesystem, label=user_input.label, mountpoint=user_input.mountpoint) actions.append( blivet.deviceaction.ActionCreateFormat( new_part, new_fmt)) elif user_input.device_type == "lvm" and not user_input.encrypt: device_name = self._pick_device_name(user_input.name) pvs = [] # exact total size of newly created pvs (future parents) total_size = blivet.size.Size("0 MiB") for parent, size in user_input.parents: dev = PartitionDevice(name="req%d" % self.storage.nextID, size=size, parents=parent) ac_part = blivet.deviceaction.ActionCreateDevice(dev) fmt = blivet.formats.getFormat(fmt_type="lvmpv") ac_fmt = blivet.deviceaction.ActionCreateFormat(dev, fmt) actions.extend([ac_part, ac_fmt]) total_size += dev.size # we need to try to create pvs immediately, if something # fails, fail now try: for ac in (ac_part, ac_fmt): self.storage.devicetree.registerAction(ac) except blivet.errors.PartitioningError as e: return ReturnList(success=False, actions=None, message=None, exception=e, traceback=sys.exc_info()[2]) pvs.append(dev) new_vg = LVMVolumeGroupDevice(size=total_size, parents=pvs, name=device_name, peSize=user_input.advanced["pesize"]) actions.append(blivet.deviceaction.ActionCreateDevice(new_vg)) elif user_input.device_type == "lvm" and user_input.encrypt: device_name = self._pick_device_name(user_input.name) lukses = [] # exact total size of newly created pvs (future parents) total_size = blivet.size.Size("0 MiB") for parent, size in user_input.parents: dev = PartitionDevice(name="req%d" % self.storage.nextID, size=user_input.size, parents=[parent]) ac_part = blivet.deviceaction.ActionCreateDevice(dev) fmt = blivet.formats.getFormat( fmt_type="luks", passphrase=user_input.passphrase, device=dev.path) ac_fmt = blivet.deviceaction.ActionCreateFormat(dev, fmt) luks_dev = LUKSDevice("luks-%s" % dev.name, fmt=blivet.formats.getFormat( "lvmpv", device=dev.path), size=dev.size, parents=[dev]) ac_luks = blivet.deviceaction.ActionCreateDevice(luks_dev) actions.extend([ac_part, ac_fmt, ac_luks]) total_size += luks_dev.size # we need to try to create pvs immediately, if something # fails, fail now try: for ac in (ac_part, ac_fmt, ac_luks): self.storage.devicetree.registerAction(ac) except blivet.errors.PartitioningError as e: return ReturnList(success=False, actions=None, message=None, exception=e, traceback=sys.exc_info()[2]) lukses.append(luks_dev) new_vg = LVMVolumeGroupDevice(size=total_size, parents=lukses, name=device_name, peSize=user_input.advanced["pesize"]) actions.append(blivet.deviceaction.ActionCreateDevice(new_vg)) elif user_input.device_type == "lvmlv": device_name = self._pick_device_name(user_input.name, user_input.parents[0][0]) new_part = LVMLogicalVolumeDevice( name=device_name, size=user_input.size, parents=[i[0] for i in user_input.parents]) actions.append(blivet.deviceaction.ActionCreateDevice(new_part)) new_fmt = blivet.formats.getFormat( fmt_type=user_input.filesystem, mountpoint=user_input.mountpoint) actions.append( blivet.deviceaction.ActionCreateFormat(new_part, new_fmt)) elif user_input.device_type == "lvmvg": device_name = self._pick_device_name(user_input.name) new_vg = LVMVolumeGroupDevice( size=user_input.size, name=device_name, parents=[i[0] for i in user_input.parents], peSize=user_input.advanced["pesize"]) actions.append(blivet.deviceaction.ActionCreateDevice(new_vg)) elif user_input.device_type == "lvmpv": if user_input.encrypt: dev = PartitionDevice( name="req%d" % self.storage.nextID, size=user_input.size, parents=[i[0] for i in user_input.parents]) actions.append(blivet.deviceaction.ActionCreateDevice(dev)) fmt = blivet.formats.getFormat( fmt_type="luks", passphrase=user_input.passphrase, device=dev.path) actions.append(blivet.deviceaction.ActionCreateFormat( dev, fmt)) luks_dev = LUKSDevice("luks-%s" % dev.name, fmt=blivet.formats.getFormat( "lvmpv", device=dev.path), size=dev.size, parents=[dev]) actions.append( blivet.deviceaction.ActionCreateDevice(luks_dev)) else: dev = PartitionDevice( name="req%d" % self.storage.nextID, size=user_input.size, parents=[i[0] for i in user_input.parents]) actions.append(blivet.deviceaction.ActionCreateDevice(dev)) fmt = blivet.formats.getFormat(fmt_type="lvmpv") actions.append(blivet.deviceaction.ActionCreateFormat( dev, fmt)) elif user_input.device_type == "btrfs volume": device_name = self._pick_device_name(user_input.name) # for btrfs we need to create parents first -- currently selected "parents" are # disks but "real parents" for subvolume are btrfs formatted partitions btrfs_parents = [] # exact total size of newly created partitions (future parents) total_size = blivet.size.Size("0 MiB") for parent, size in user_input.parents: if user_input.btrfs_type == "disks": assert parent.isDisk fmt = blivet.formats.getFormat(fmt_type="btrfs") ac_fmt = blivet.deviceaction.ActionCreateFormat( parent, fmt) actions.append(ac_fmt) try: self.storage.devicetree.registerAction(ac_fmt) except Exception as e: # pylint: disable=broad-except return ReturnList(success=False, actions=None, message=None, exception=e, traceback=sys.exc_info()[2]) total_size += size btrfs_parents.append(parent) else: dev = PartitionDevice(name="req%d" % self.storage.nextID, size=size, parents=[parent]) ac_part = blivet.deviceaction.ActionCreateDevice(dev) fmt = blivet.formats.getFormat(fmt_type="btrfs") ac_fmt = blivet.deviceaction.ActionCreateFormat(dev, fmt) actions.extend([ac_part, ac_fmt]) total_size += dev.size # we need to try to create partitions immediately, if something # fails, fail now try: for ac in (ac_part, ac_fmt): self.storage.devicetree.registerAction(ac) except blivet.errors.PartitioningError as e: return ReturnList(success=False, actions=None, message=None, exception=e, traceback=sys.exc_info()[2]) btrfs_parents.append(dev) new_btrfs = BTRFSVolumeDevice(device_name, size=total_size, parents=btrfs_parents) new_btrfs.format = blivet.formats.getFormat( "btrfs", label=device_name, mountpoint=user_input.mountpoint) actions.append(blivet.deviceaction.ActionCreateDevice(new_btrfs)) elif user_input.device_type == "btrfs subvolume": device_name = self._pick_device_name(user_input.name, user_input.parents[0][0]) new_btrfs = BTRFSSubVolumeDevice( device_name, parents=[i[0] for i in user_input.parents]) new_btrfs.format = blivet.formats.getFormat( "btrfs", mountpoint=user_input.mountpoint) actions.append(blivet.deviceaction.ActionCreateDevice(new_btrfs)) elif user_input.device_type == "mdraid": device_name = self._pick_device_name(user_input.name) parts = [] # exact total size of newly created pvs (future parents) total_size = blivet.size.Size("0 MiB") for parent, size in user_input.parents: dev = PartitionDevice(name="req%d" % self.storage.nextID, size=size, parents=[parent]) ac_part = blivet.deviceaction.ActionCreateDevice(dev) fmt = blivet.formats.getFormat(fmt_type="mdmember") ac_fmt = blivet.deviceaction.ActionCreateFormat(dev, fmt) actions.extend([ac_part, ac_fmt]) total_size += dev.size # we need to try to create pvs immediately, if something # fails, fail now try: for ac in (ac_part, ac_fmt): self.storage.devicetree.registerAction(ac) except blivet.errors.PartitioningError as e: return ReturnList(success=False, actions=None, message=None, exception=e, traceback=sys.exc_info()[2]) parts.append(dev) new_md = MDRaidArrayDevice(size=total_size, parents=parts, name=device_name, level=user_input.raid_level, memberDevices=len(parts), totalDevices=len(parts)) actions.append(blivet.deviceaction.ActionCreateDevice(new_md)) fmt = blivet.formats.getFormat(fmt_type=user_input.filesystem) actions.append(blivet.deviceaction.ActionCreateFormat(new_md, fmt)) try: for ac in actions: if not ac._applied: self.storage.devicetree.registerAction(ac) blivet.partitioning.doPartitioning(self.storage) except Exception as e: # pylint: disable=broad-except return ReturnList(success=False, actions=None, message=None, exception=e, traceback=sys.exc_info()[2]) return ReturnList(success=True, actions=actions, message=None, exception=None, traceback=None)
def setUp(self): parents = [ DiskDevice("name1", fmt=getFormat("mdmember")) ] self.dev1 = MDContainerDevice("dev1", level="container", parents=parents) parents = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")) ] self.dev2 = MDRaidArrayDevice("dev2", level="raid0", parents=parents) parents = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")) ] self.dev3 = MDRaidArrayDevice("dev3", level="raid1", parents=parents) parents = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")), DiskDevice("name3", fmt=getFormat("mdmember")) ] self.dev4 = MDRaidArrayDevice("dev4", level="raid4", parents=parents) parents = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")), DiskDevice("name3", fmt=getFormat("mdmember")) ] self.dev5 = MDRaidArrayDevice("dev5", level="raid5", parents=parents) parents = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")), DiskDevice("name3", fmt=getFormat("mdmember")), DiskDevice("name4", fmt=getFormat("mdmember")) ] self.dev6 = MDRaidArrayDevice("dev6", level="raid6", parents=parents) parents = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")), DiskDevice("name3", fmt=getFormat("mdmember")), DiskDevice("name4", fmt=getFormat("mdmember")) ] self.dev7 = MDRaidArrayDevice("dev7", level="raid10", parents=parents) self.dev8 = MDRaidArrayDevice("dev8", level=1, exists=True) parents_1 = [ DiskDevice("name1", fmt=getFormat("mdmember")) ] dev_1 = MDContainerDevice( "parent", level="container", parents=parents_1 ) parents_2 = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")) ] dev_2 = MDRaidArrayDevice( "other", level=0, fmt=getFormat("mdmember"), parents=parents_2 ) self.dev9 = MDBiosRaidArrayDevice( "dev9", level="raid0", memberDevices=2, parents=[dev_1, dev_2], totalDevices=2 ) parents = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")) ] self.dev10 = MDRaidArrayDevice( "dev10", level="raid0", parents=parents, size=Size("32 MiB")) parents_1 = [ DiskDevice("name1", fmt=getFormat("mdmember")) ] dev_1 = MDContainerDevice( "parent", level="container", parents=parents ) parents_2 = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")) ] dev_2 = MDRaidArrayDevice( "other", level=0, fmt=getFormat("mdmember"), parents=parents_2 ) self.dev11 = MDBiosRaidArrayDevice( "dev11", level=1, memberDevices=2, parents=[dev_1, dev_2], size=Size("32 MiB"), totalDevices=2) self.dev12 = MDBiosRaidArrayDevice( "dev12", level=1, memberDevices=2, parents=[ Mock(**{"type": "mdcontainer", "size": Size("4 MiB"), "format": getFormat(None)}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")})], size=Size("32 MiB"), totalDevices=2) self.dev13 = MDRaidArrayDevice( "dev13", level=0, memberDevices=3, parents=[ Mock(**{"size": Size("4 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")})], size=Size("32 MiB"), totalDevices=3) self.dev14 = MDRaidArrayDevice( "dev14", level=4, memberDevices=3, parents=[ Mock(**{"size": Size("4 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")})], totalDevices=3) self.dev15 = MDRaidArrayDevice( "dev15", level=5, memberDevices=3, parents=[ Mock(**{"size": Size("4 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")})], totalDevices=3) self.dev16 = MDRaidArrayDevice( "dev16", level=6, memberDevices=4, parents=[ Mock(**{"size": Size("4 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("4 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")})], totalDevices=4) self.dev17 = MDRaidArrayDevice( "dev17", level=10, memberDevices=4, parents=[ Mock(**{"size": Size("4 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("4 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")})], totalDevices=4) self.dev18 = MDRaidArrayDevice( "dev18", level=10, memberDevices=4, parents=[ Mock(**{"size": Size("4 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("4 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")}), Mock(**{"size": Size("2 MiB"), "format": getFormat("mdmember")})], totalDevices=5) parents = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")) ] self.dev19 = MDRaidArrayDevice( "dev19", level="raid1", parents=parents, uuid='3386ff85-f501-2621-4a43-5f061eb47236' ) parents = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")) ] self.dev20 = MDRaidArrayDevice( "dev20", level="raid1", parents=parents, uuid='Just-pretending' )