def testFormatsMethods(self): ## ## get_device_format_class ## format_pairs = { None : None, "bogus" : None, "biosboot" : formats.biosboot.BIOSBoot, "BIOS Boot" : formats.biosboot.BIOSBoot, "nodev" : formats.fs.NoDevFS } format_names = format_pairs.keys() format_values = [format_pairs[k] for k in format_names] self.assertEqual( [formats.get_device_format_class(x) for x in format_names], format_values) ## A DeviceFormat object is returned if lookup by name fails for name in format_names: self.assertIs(formats.getFormat(name).__class__, formats.DeviceFormat if format_pairs[name] is None else format_pairs[name]) ## Consecutively constructed DeviceFormat objects have consecutive ids names = [key for key in format_pairs.keys() if format_pairs[key] is not None] objs = [formats.getFormat(name) for name in names] ids = [obj.id for obj in objs] self.assertEqual(ids, range(ids[0], ids[0] + len(ids))) ## Copy or deepcopy should preserve the id self.assertEqual(ids, [copy.copy(obj).id for obj in objs]) self.assertEqual(ids, [copy.deepcopy(obj).id for obj in objs])
def testMDFactory(self): with self.assertRaisesRegex(devicefactory.DeviceFactoryError, "must have some RAID level"): devicefactory.get_device_factory( self.b, devicefactory.DEVICE_TYPE_MD, Size("1 GiB")) with self.assertRaisesRegex(RaidError, "requires at least"): self.factory1._get_device_space() with self.assertRaisesRegex(RaidError, "requires at least"): self.factory1._configure() self.assertEqual(self.factory1.container_list, []) self.assertIsNone(self.factory1.get_container()) parents = [ DiskDevice("name1", fmt=getFormat("mdmember")), DiskDevice("name2", fmt=getFormat("mdmember")) ] self.assertIsNotNone(self.factory1._get_new_device(parents=parents)) with self.assertRaisesRegex(RaidError, "requires at least"): self.factory2._get_device_space() self.assertEqual(self.factory2.container_list, []) self.assertIsNone(self.factory2.get_container())
def testNetDevSetting(self): """ Verify netdev mount option setting after format assignment. """ netdev = FakeNetDev("net1") dev = StorageDevice("dev1", fmt=getFormat("ext4")) self.assertFalse("_netdev" in dev.format.options.split(",")) dev.parents.append(netdev) dev.format = getFormat("ext4") self.assertTrue("_netdev" in dev.format.options.split(","))
def setUp(self): dev1 = DiskDevice("name", fmt=getFormat("mdmember"), size=Size("1 GiB")) 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"), totalDevices=2, memberDevices=2) 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 testDependencies(self): dev1 = DiskDevice("name", fmt=getFormat("mdmember")) dev2 = DiskDevice("other", fmt=getFormat("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.externalDependencies: self.assertIn(d, luks.externalDependencies) # make sure that there's at least something in these dependencies self.assertGreater(len(luks.externalDependencies), 0)
def newFormat(self, *args, **kwargs): """ Return a new DeviceFormat instance suitable for testing. Keyword Arguments: device_instance - StorageDevice instance this format will be created on. This is needed for setup of resizable formats. All other arguments are passed directly to blivet.formats.getFormat. """ exists = kwargs.pop("exists", False) device_instance = kwargs.pop("device_instance", None) fmt = getFormat(*args, **kwargs) if isinstance(fmt, blivet.formats.disklabel.DiskLabel): fmt._partedDevice = Mock() fmt._partedDisk = Mock() attrs = {"partitions": []} fmt._partedDisk.configure_mock(**attrs) fmt.exists = exists if exists: fmt._resizable = fmt.__class__._resizable if fmt.resizable and device_instance: fmt._size = device_instance.currentSize return fmt
def newFormat(*args, **kwargs): """ Return a new DeviceFormat instance suitable for testing. Keyword Arguments: device_instance - StorageDevice instance this format will be created on. This is needed for setup of resizable formats. All other arguments are passed directly to blivet.formats.getFormat. """ args = args[1:] # drop self arg exists = kwargs.pop("exists", False) device_instance = kwargs.pop("device_instance", None) format = getFormat(*args, **kwargs) if isinstance(format, blivet.formats.disklabel.DiskLabel): format._partedDevice = Mock() format._partedDisk = Mock() format.exists = exists if format.resizable and device_instance: format._size = device_instance.currentSize return format
def testAvailabilityMDRAIDplugin(self): availability.CACHE_AVAILABILITY = False availability.BLOCKDEV_DM_PLUGIN._method = availability.AvailableMethod # if the plugin is not in, there's nothing to test self.assertIn(availability.BLOCKDEV_MDRAID_PLUGIN, self.luks.externalDependencies) # dev is not among its unavailable dependencies availability.BLOCKDEV_MDRAID_PLUGIN._method = availability.AvailableMethod self.assertNotIn(availability.BLOCKDEV_MDRAID_PLUGIN, self.luks.unavailableDependencies) self.assertIsNotNone(ActionCreateDevice(self.luks)) self.assertIsNotNone(ActionDestroyDevice(self.luks)) self.assertIsNotNone(ActionCreateFormat(self.luks, fmt=getFormat("macefi"))) self.assertIsNotNone(ActionDestroyFormat(self.luks)) # dev is among the unavailable dependencies availability.BLOCKDEV_MDRAID_PLUGIN._method = availability.UnavailableMethod self.assertIn(availability.BLOCKDEV_MDRAID_PLUGIN, self.luks.unavailableDependencies) with self.assertRaises(ValueError): ActionCreateDevice(self.luks) with self.assertRaises(ValueError): ActionDestroyDevice(self.dev) with self.assertRaises(ValueError): ActionCreateFormat(self.dev) with self.assertRaises(ValueError): ActionDestroyFormat(self.dev)
def testActionCreation(self): """ Verify correct operation of action class constructors. """ # instantiation of device resize action for non-existent device should # fail # XXX resizable depends on existence, so this is covered implicitly sdd = self.storage.devicetree.getDeviceByName("sdd") p = self.newDevice(device_class=PartitionDevice, name="sdd1", size=Size("32 GiB"), parents=[sdd]) with self.assertRaises(ValueError): ActionResizeDevice(p, p.size + Size("7232 MiB")) # instantiation of device resize action for non-resizable device # should fail vg = self.storage.devicetree.getDeviceByName("VolGroup") self.assertNotEqual(vg, None) with self.assertRaises(ValueError): ActionResizeDevice(vg, vg.size + Size("32 MiB")) # instantiation of format resize action for non-resizable format type # should fail lv_swap = self.storage.devicetree.getDeviceByName("VolGroup-lv_swap") self.assertNotEqual(lv_swap, None) with self.assertRaises(ValueError): ActionResizeFormat(lv_swap, lv_swap.size + Size("32 MiB")) # instantiation of format resize action for non-existent format # should fail lv_root = self.storage.devicetree.getDeviceByName("VolGroup-lv_root") self.assertNotEqual(lv_root, None) lv_root.format.exists = False with self.assertRaises(ValueError): ActionResizeFormat(lv_root, lv_root.size - Size("1000 MiB")) lv_root.format.exists = True # instantiation of device create action for existing device should # fail lv_swap = self.storage.devicetree.getDeviceByName("VolGroup-lv_swap") self.assertNotEqual(lv_swap, None) self.assertEqual(lv_swap.exists, True) with self.assertRaises(ValueError): ActionCreateDevice(lv_swap) # instantiation of format destroy action for device causes device's # format attribute to be a DeviceFormat instance lv_swap = self.storage.devicetree.getDeviceByName("VolGroup-lv_swap") self.assertNotEqual(lv_swap, None) orig_format = lv_swap.format self.assertEqual(lv_swap.format.type, "swap") destroy_swap = ActionDestroyFormat(lv_swap) self.assertEqual(lv_swap.format.type, "swap") destroy_swap.apply() self.assertEqual(lv_swap.format.type, None) # instantiation of format create action for device causes new format # to be accessible via device's format attribute new_format = getFormat("vfat", device=lv_swap.path) create_swap = ActionCreateFormat(lv_swap, new_format) self.assertEqual(lv_swap.format.type, None) create_swap.apply() self.assertEqual(lv_swap.format, new_format) lv_swap.format = orig_format
def _set_up_storage(self): # Don't rely on the default being an msdos disklabel since the test # could be running on an EFI system. for name in self.disks: disk = self.blivet.devicetree.getDeviceByName(name) fmt = getFormat("disklabel", labelType="msdos", device=disk.path) self.blivet.formatDevice(disk, fmt)
def testPackages(self): dev1 = DiskDevice("name", fmt=getFormat("mdmember")) dev2 = DiskDevice("other", fmt=getFormat("mdmember")) dev = MDRaidArrayDevice("dev", level="raid1", parents=[dev1,dev2]) luks = LUKSDevice("luks", parents=[dev]) packages = luks.packages # no duplicates in list of packages self.assertListEqual(packages, list(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 testVGChunkWithCachePVfree(self): pv = StorageDevice("pv1", size=Size("40 GiB"), fmt=getFormat("lvmpv")) # 1077 MiB so that the PV provides 1076 MiB of free space (see # LVMVolumeGroupDevice.extents) which is 44 MiB more than the caches # need (including the 8MiB pmspare LV) and which should thus be split # into the LVs pv2 = StorageDevice("pv2", size=Size("1077 MiB"), fmt=getFormat("lvmpv")) vg = LVMVolumeGroupDevice("vg", parents=[pv, pv2]) cache_req1 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough") lv1 = LVMLogicalVolumeDevice("lv1", parents=[vg], size=Size("1 GiB"), grow=True, cacheRequest=cache_req1) cache_req2 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough") lv2 = LVMLogicalVolumeDevice("lv2", parents=[vg], size=Size("10 GiB"), grow=True, cacheRequest=cache_req2) lv3 = LVMLogicalVolumeDevice("lv3", parents=[vg], size=Size("10 GiB"), grow=True, maxsize=Size("12 GiB")) req1 = LVRequest(lv1) req2 = LVRequest(lv2) req3 = LVRequest(lv3) chunk = VGChunk(vg, requests=[req1, req2, req3]) chunk.growRequests() # the chunk is done growing since its pool has been exhausted self.assertEqual(chunk.done, True) # there are still two requests remaining since lv1 and lv2 have no max self.assertEqual(chunk.remaining, 2) # All the sizes should be the same as without the caches (see the # testVGChunk test for their "rationales") because the space for the # caches should just be reserved. # The extra 11 extents available on the pv2 should go in the 1:10 ratio # to req1 and req2. self.assertEqual(req1.growth, 395 + 1) self.assertEqual(req2.growth, 3956 + 10) self.assertEqual(req3.growth, 512)
def testSizeSetter(self): initial_size = Size('10 GiB') new_size = Size('2 GiB') ## ## setter sets the size ## dev = self._getDevice('sizetest', size=initial_size) self.assertEqual(dev.size, initial_size) dev.size = new_size self.assertEqual(dev.size, new_size) ## ## setter raises exn if size outside of format limits ## dev.format._maxSize = Size("5 GiB") with self.assertRaises(errors.DeviceError): dev.size = Size("6 GiB") ## ## new formats' min size is checked against device size ## fmt = getFormat(None) fmt._minSize = Size("10 GiB") with self.assertRaises(errors.DeviceError): dev.format = fmt # the format assignment should succeed without the min size conflict fmt._minSize = Size(0) dev.format = fmt ## ## new formats' max size is checked against device size ## fmt = getFormat(None) fmt._maxSize = Size("10 MiB") with self.assertRaises(errors.DeviceError): dev.format = fmt # the format assignment should succeed without the min size conflict fmt._maxSize = Size(0) dev.format = fmt
def testVGChunkWithCache(self): pv = StorageDevice("pv1", size=Size("40 GiB"), fmt=getFormat("lvmpv")) # 1033 MiB so that the PV provides 1032 MiB of free space (see # LVMVolumeGroupDevice.extents) -- 1024 MiB for caches, 8 MiB for the # pmspare LV pv2 = StorageDevice("pv2", size=Size("1033 MiB"), fmt=getFormat("lvmpv")) vg = LVMVolumeGroupDevice("vg", parents=[pv, pv2]) cache_req1 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough") lv1 = LVMLogicalVolumeDevice("lv1", parents=[vg], size=Size("1 GiB"), grow=True, cacheRequest=cache_req1) cache_req2 = LVMCacheRequest(Size("512 MiB"), [pv2], "writethrough") lv2 = LVMLogicalVolumeDevice("lv2", parents=[vg], size=Size("10 GiB"), grow=True, cacheRequest=cache_req2) lv3 = LVMLogicalVolumeDevice("lv3", parents=[vg], size=Size("10 GiB"), grow=True, maxsize=Size("12 GiB")) req1 = LVRequest(lv1) req2 = LVRequest(lv2) req3 = LVRequest(lv3) chunk = VGChunk(vg, requests=[req1, req2, req3]) chunk.growRequests() # the chunk is done growing since its pool has been exhausted self.assertEqual(chunk.done, True) # there are still two requests remaining since lv1 and lv2 have no max self.assertEqual(chunk.remaining, 2) # All the sizes should be the same as without the caches (see the # testVGChunk test for their "rationales") because the space for the # caches should just be reserved. self.assertEqual(req1.growth, 395) self.assertEqual(req2.growth, 3956) self.assertEqual(req3.growth, 512)
def testNetDevUpdate(self): """ Verify netdev mount option setting after device creation. """ netdev = FakeNetDev("net1") dev = StorageDevice("dev1", fmt=getFormat("ext4")) self.assertFalse("_netdev" in dev.format.options.split(",")) dev.parents.append(netdev) # these create methods shouldn't write anything to disk netdev.create() dev.create() self.assertTrue("_netdev" in dev.format.options.split(","))
def testDiskChunk1(self): disk_size = Size("100 MiB") with sparsetmpfile("chunktest", disk_size) as disk_file: disk = DiskFile(disk_file) disk.format = getFormat("disklabel", device=disk.path, exists=False) p1 = PartitionDevice("p1", size=Size("10 MiB"), grow=True) p2 = PartitionDevice("p2", size=Size("30 MiB"), grow=True) disks = [disk] partitions = [p1, p2] free = getFreeRegions([disk]) self.assertEqual(len(free), 1, "free region count %d not expected" % len(free)) b = Mock() allocatePartitions(b, disks, partitions, free) requests = [PartitionRequest(p) for p in partitions] chunk = DiskChunk(free[0], requests=requests) # parted reports a first free sector of 32 for disk files. whatever. length_expected = 204768 self.assertEqual(chunk.length, length_expected) base_expected = sum(p.partedPartition.geometry.length for p in partitions) self.assertEqual(chunk.base, base_expected) pool_expected = chunk.length - base_expected self.assertEqual(chunk.pool, pool_expected) self.assertEqual(chunk.done, False) self.assertEqual(chunk.remaining, 2) chunk.growRequests() self.assertEqual(chunk.done, True) self.assertEqual(chunk.pool, 0) self.assertEqual(chunk.remaining, 2) # # validate the growth (everything in sectors) # # The chunk length is 204768. The base of p1 is 20480. The base of # p2 is 61440. The chunk has a base of 81920 and a pool of 122848. # # p1 should grow by 30712 while p2 grows by 92136 since p2's base # size is exactly three times that of p1. self.assertEqual(requests[0].growth, 30712) self.assertEqual(requests[1].growth, 92136)
def populate_mountpoint_store(store, used_mountpoints): # sure, add whatever you want to this list. this is just a start. paths = ["/", "/boot", "/home", "/var"] + platform.bootStage1ConstraintDict["mountpoints"] # Sort the list now so all the real mountpoints go to the front, then # add all the pseudo mountpoints we have. paths.sort() paths += ["swap"] for fmt in ["appleboot", "biosboot", "prepboot"]: if getFormat(fmt).supported: paths += [fmt] for path in paths: if path not in used_mountpoints: store.append([path])
def testNormalizeSize(self): ## _normalize_size should adjust target size to within the format limits fstype = "ext2" ext2 = getFormat(fstype) self.assertTrue(ext2.maxSize > Size(0)) size = Size("9 TiB") self.assertTrue(size > ext2.maxSize) kwargs = self._getTestFactoryArgs() factory = devicefactory.get_device_factory(self.b, self.device_type, size, disks=self.b.disks, fstype=fstype, **kwargs) factory._normalize_size() self.assertTrue(factory.size <= ext2.maxSize) ## _normalize_size should convert a size of None to a reasonable guess ## at the largest possible size based on disk free space factory.size = None factory._normalize_size() self.assertIsInstance(factory.size, blivet.size.Size) self.assertTrue(factory.size <= ext2.maxSize) # Allow some variation in size for metadata, alignment, &c. self.assertAlmostEqual(factory.size, sum(d.size for d in self.b.disks), delta=self._getSizeDelta()) ## _handle_no_size should also take into account any specified factory ## device, in case the factory is to be modifying a defined device # must be a couple MiB smaller than the disk to accommodate # PartitionFactory size = self.b.disks[0].size - Size("4 MiB") device = self._factoryDevice(self.device_type, size, disks=self.b.disks, **kwargs) self.assertAlmostEqual(device.size, size, delta=self._getSizeDelta()) factory.size = None factory.device = device factory._normalize_size() self.assertIsInstance(factory.size, blivet.size.Size) self.assertTrue(factory.size <= ext2.maxSize) ## factory size should be total disk space plus current device space # Allow some variation in size for metadata, alignment, &c. self.assertAlmostEqual(factory.size, sum(d.size for d in self.b.disks), delta=self._getSizeDelta(devices=[device]))
def testGetContainer(self): for disk in self.b.disks: self.b.formatDevice(disk, getFormat("lvmpv")) vg = self.b.newVG(parents=self.b.disks, name="newvg") self.b.createDevice(vg) self.assertEqual(self.b.vgs, [vg]) factory = devicefactory.get_device_factory(self.b, self.device_type, Size("500 MiB"), fstype="xfs") ## get_container on lvm factory should return the lone non-existent vg self.assertEqual(factory.get_container(), vg) ## get_container should require allow_existing to return an existing vg vg.exists = True vg._complete = True self.assertEqual(factory.get_container(), None) self.assertEqual(factory.get_container(allow_existing=True), vg)
def testExtendedMinSize(self): with sparsetmpfile("extendedtest", Size("10 MiB")) as disk_file: disk = DiskFile(disk_file) disk.format = getFormat("disklabel", device=disk.path) grain_size = Size(disk.format.alignment.grainSize) sector_size = Size(disk.format.partedDevice.sectorSize) extended_start = int(grain_size) extended_end = extended_start + int(Size("6 MiB") / sector_size) disk.format.addPartition(extended_start, extended_end, parted.PARTITION_EXTENDED) extended = disk.format.extendedPartition self.assertNotEqual(extended, None) extended_device = PartitionDevice(os.path.basename(extended.path)) extended_device.disk = disk extended_device.exists = True extended_device.partedPartition = extended # no logical partitions --> min size should be max of 1 KiB and grainSize self.assertEqual(extended_device.minSize, extended_device.alignTargetSize(max(grain_size, Size("1 KiB")))) logical_start = extended_start + 1 logical_end = extended_end // 2 disk.format.addPartition(logical_start, logical_end, parted.PARTITION_LOGICAL) logical = disk.format.partedDisk.getPartitionBySector(logical_start) self.assertNotEqual(logical, None) logical_device = PartitionDevice(os.path.basename(logical.path)) logical_device.disk = disk logical_device.exists = True logical_device.partedPartition = logical # logical partition present --> min size should be based on its end sector end_free = (extended_end - logical_end)*sector_size self.assertEqual(extended_device.minSize, extended_device.alignTargetSize(extended_device.currentSize - end_free))
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, level=lambda x, m: self.assertEqual(x.name, "container", m), type=lambda x, m: self.assertEqual(x, "mdcontainer", m)) self.stateCheck(self.dev2, createBitmap=self.assertFalse, level=lambda x, m: self.assertEqual(x.number, 0, m)) self.stateCheck(self.dev3, level=lambda x, m: self.assertEqual(x.number, 1, m)) self.stateCheck(self.dev4, level=lambda x, m: self.assertEqual(x.number, 4, m)) self.stateCheck(self.dev5, level=lambda x, m: self.assertEqual(x.number, 5, m)) self.stateCheck(self.dev6, level=lambda x, m: self.assertEqual(x.number, 6, m)) self.stateCheck(self.dev7, level=lambda x, m: self.assertEqual(x.number, 10, m)) ## ## existing device tests ## self.stateCheck(self.dev8, exists=self.assertTrue, level=lambda x, m: self.assertEqual(x.number, 1, m), metadataVersion=self.assertIsNone) ## ## mdbiosraidarray tests ## self.stateCheck(self.dev9, createBitmap=self.assertFalse, devices=lambda x, m: self.assertEqual(len(x), 2, m), isDisk=self.assertTrue, level=lambda x, m: self.assertEqual(x.number, 0, m), mediaPresent=self.assertTrue, memberDevices=lambda x, m: self.assertEqual(x, 2, m), parents=lambda x, m: self.assertNotEqual(x, [], m), partitionable=self.assertTrue, totalDevices=lambda x, m: self.assertEqual(x, 2, m), type = lambda x, m: self.assertEqual(x, "mdbiosraidarray", m)) ## ## size tests ## self.stateCheck(self.dev10, createBitmap=self.assertFalse, level=lambda x, m: self.assertEqual(x.number, 0, m), targetSize=lambda x, m: self.assertEqual(x, Size("32 MiB"), m)) self.stateCheck(self.dev11, devices=lambda x, m: self.assertEqual(len(x), 2, m), isDisk=self.assertTrue, level=lambda x, m: self.assertEqual(x.number, 1, m), mediaPresent=self.assertTrue, memberDevices=lambda x, m: self.assertEqual(x, 2, m), parents=lambda x, m: self.assertNotEqual(x, [], m), partitionable=self.assertTrue, targetSize=lambda x, m: self.assertEqual(x, Size("32 MiB"), m), totalDevices=lambda x, m: self.assertEqual(x, 2, m), type=lambda x, m: self.assertEqual(x, "mdbiosraidarray", m)) self.stateCheck(self.dev12, devices=lambda x, m: self.assertEqual(len(x), 2, m), isDisk=self.assertTrue, level=lambda x, m: self.assertEqual(x.number, 1, m), mediaPresent=self.assertTrue, memberDevices=lambda x, m: self.assertEqual(x, 2, m), parents=lambda x, m: self.assertNotEqual(x, [], m), partitionable=self.assertTrue, targetSize=lambda x, m: self.assertEqual(x, Size("32 MiB"), m), totalDevices=lambda x, m: self.assertEqual(x, 2, m), type = lambda x, m: self.assertEqual(x, "mdbiosraidarray", m)) self.stateCheck(self.dev13, createBitmap=self.assertFalse, devices=lambda x, m: self.assertEqual(len(x), 2, m), level=lambda x, m: self.assertEqual(x.number, 0, m), memberDevices=lambda x, m: self.assertEqual(x, 3, m), parents=lambda x, m: self.assertNotEqual(x, [], m), size=lambda x, m: self.assertEqual(x, Size("3 MiB"), m), targetSize=lambda x, m: self.assertEqual(x, Size("32 MiB"), m), totalDevices=lambda x, m: self.assertEqual(x, 3, m)) self.stateCheck(self.dev14, devices=lambda x, m: self.assertEqual(len(x), 3, m), level=lambda x, m: self.assertEqual(x.number, 4, m), memberDevices=lambda x, m: self.assertEqual(x, 3, m), parents=lambda x, m: self.assertNotEqual(x, [], m), size=lambda x, m: self.assertEqual(x, Size("2 MiB"), m), totalDevices=lambda x, m: self.assertEqual(x, 3, m)) self.stateCheck(self.dev15, devices=lambda x, m: self.assertEqual(len(x), 3, m), level=lambda x, m: self.assertEqual(x.number, 5, m), memberDevices=lambda x, m: self.assertEqual(x, 3, m), parents=lambda x, m: self.assertNotEqual(x, [], m), size=lambda x, m: self.assertEqual(x, Size("2 MiB"), m), totalDevices=lambda x, m: self.assertEqual(x, 3, m)) self.stateCheck(self.dev16, devices=lambda x, m: self.assertEqual(len(x), 4, m), level=lambda x, m: self.assertEqual(x.number, 6, m), memberDevices=lambda x, m: self.assertEqual(x, 4, m), parents=lambda x, m: self.assertNotEqual(x, [], m), size=lambda x, m: self.assertEqual(x, Size("2 MiB"), m), totalDevices=lambda x, m: self.assertEqual(x, 4, m)) self.stateCheck(self.dev17, devices=lambda x, m: self.assertEqual(len(x), 4, m), level=lambda x, m: self.assertEqual(x.number, 10, m), memberDevices=lambda x, m: self.assertEqual(x, 4, m), parents=lambda x, m: self.assertNotEqual(x, [], m), size=lambda x, m: self.assertEqual(x, Size("2 MiB"), m), totalDevices=lambda x, m: self.assertEqual(x, 4, m)) self.stateCheck(self.dev18, devices=lambda x, m: self.assertEqual(len(x), 4, m), level=lambda x, m: self.assertEqual(x.number, 10, m), memberDevices=lambda x, m: self.assertEqual(x, 4, m), parents=lambda x, m: self.assertNotEqual(x, [], m), size=lambda x, m: self.assertEqual(x, Size("2 MiB"), m), spares=lambda x, m: self.assertEqual(x, 1, m), totalDevices=lambda x, m: self.assertEqual(x, 5, m)) self.assertRaisesRegexp(MDRaidError, "invalid RAID level", MDRaidArrayDevice, "dev") self.assertRaisesRegexp(MDRaidError, "invalid RAID level", MDRaidArrayDevice, "dev", level="raid2") self.assertRaisesRegexp(MDRaidError, "invalid RAID level", MDRaidArrayDevice, "dev", parents=[StorageDevice("parent", fmt=getFormat("mdmember"))]) self.assertRaisesRegexp(DeviceError, "set requires at least 2 members", MDRaidArrayDevice, "dev", level="raid0", parents=[StorageDevice("parent", fmt=getFormat("mdmember"))]) self.assertRaisesRegexp(MDRaidError, "invalid RAID level descriptor junk", MDRaidArrayDevice, "dev", level="junk") self.assertRaisesRegexp(ValueError, "memberDevices cannot be greater than totalDevices", 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 testMDRaidArrayDeviceInit(self, *args, **kwargs): """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, level=lambda x, m: self.assertEqual(x.name, "container", m), type=lambda x, m: self.assertEqual(x, "mdcontainer", m)) self.stateCheck(self.dev2, createBitmap=self.assertFalse, level=lambda x, m: self.assertEqual(x.number, 0, m)) self.stateCheck(self.dev3, level=lambda x, m: self.assertEqual(x.number, 1, m)) self.stateCheck(self.dev4, level=lambda x, m: self.assertEqual(x.number, 4, m)) self.stateCheck(self.dev5, level=lambda x, m: self.assertEqual(x.number, 5, m)) self.stateCheck(self.dev6, level=lambda x, m: self.assertEqual(x.number, 6, m)) self.stateCheck(self.dev7, level=lambda x, m: self.assertEqual(x.number, 10, m)) ## ## existing device tests ## self.stateCheck(self.dev8, exists=self.assertTrue, level=lambda x, m: self.assertEqual(x.number, 1, m), metadataVersion=self.assertIsNone) ## ## mdbiosraidarray tests ## self.stateCheck( self.dev9, createBitmap=self.assertFalse, devices=lambda x, m: self.assertEqual(len(x), 2, m), isDisk=self.assertTrue, level=lambda x, m: self.assertEqual(x.number, 0, m), mediaPresent=self.assertTrue, memberDevices=lambda x, m: self.assertEqual(x, 2, m), parents=lambda x, m: self.assertNotEqual(x, [], m), partitionable=self.assertTrue, smallestMember=self.assertIsNotNone, totalDevices=lambda x, m: self.assertEqual(x, 2, m), type=lambda x, m: self.assertEqual(x, "mdbiosraidarray", m)) ## ## size tests ## self.stateCheck(self.dev10, createBitmap=self.assertFalse, level=lambda x, m: self.assertEqual(x.number, 0, m), targetSize=lambda x, m: self.assertEqual( x, Size(spec="32 MiB"), m)) self.stateCheck( self.dev11, devices=lambda x, m: self.assertEqual(len(x), 2, m), isDisk=self.assertTrue, level=lambda x, m: self.assertEqual(x.number, 1, m), mediaPresent=self.assertTrue, memberDevices=lambda x, m: self.assertEqual(x, 2, m), parents=lambda x, m: self.assertNotEqual(x, [], m), partitionable=self.assertTrue, smallestMember=self.assertIsNotNone, targetSize=lambda x, m: self.assertEqual(x, Size(spec="32 MiB"), m ), totalDevices=lambda x, m: self.assertEqual(x, 2, m), type=lambda x, m: self.assertEqual(x, "mdbiosraidarray", m)) ## ## rawArraySize tests ## self.stateCheck( self.dev12, devices=lambda x, m: self.assertEqual(len(x), 2, m), isDisk=self.assertTrue, level=lambda x, m: self.assertEqual(x.number, 1, m), mediaPresent=self.assertTrue, memberDevices=lambda x, m: self.assertEqual(x, 2, m), parents=lambda x, m: self.assertNotEqual(x, [], m), partitionable=self.assertTrue, rawArraySize=lambda x, m: self.assertEqual(x, Size(spec="2 MiB"), m ), smallestMember=self.assertIsNotNone, targetSize=lambda x, m: self.assertEqual(x, Size(spec="32 MiB"), m ), totalDevices=lambda x, m: self.assertEqual(x, 2, m), type=lambda x, m: self.assertEqual(x, "mdbiosraidarray", m)) self.stateCheck( self.dev13, createBitmap=self.assertFalse, devices=lambda x, m: self.assertEqual(len(x), 2, m), level=lambda x, m: self.assertEqual(x.number, 0, m), memberDevices=lambda x, m: self.assertEqual(x, 3, m), parents=lambda x, m: self.assertNotEqual(x, [], m), rawArraySize=lambda x, m: self.assertEqual(x, Size(spec="6 MiB"), m ), size=lambda x, m: self.assertEqual(x, Size(spec="3 MiB"), m), smallestMember=self.assertIsNotNone, targetSize=lambda x, m: self.assertEqual(x, Size(spec="32 MiB"), m ), totalDevices=lambda x, m: self.assertEqual(x, 3, m)) self.stateCheck( self.dev14, devices=lambda x, m: self.assertEqual(len(x), 3, m), level=lambda x, m: self.assertEqual(x.number, 4, m), memberDevices=lambda x, m: self.assertEqual(x, 3, m), parents=lambda x, m: self.assertNotEqual(x, [], m), rawArraySize=lambda x, m: self.assertEqual(x, Size(spec="4 MiB"), m ), size=lambda x, m: self.assertEqual(x, Size(spec="2 MiB"), m), smallestMember=self.assertIsNotNone, totalDevices=lambda x, m: self.assertEqual(x, 3, m)) self.stateCheck( self.dev15, devices=lambda x, m: self.assertEqual(len(x), 3, m), level=lambda x, m: self.assertEqual(x.number, 5, m), memberDevices=lambda x, m: self.assertEqual(x, 3, m), parents=lambda x, m: self.assertNotEqual(x, [], m), rawArraySize=lambda x, m: self.assertEqual(x, Size(spec="4 MiB"), m ), size=lambda x, m: self.assertEqual(x, Size(spec="2 MiB"), m), smallestMember=self.assertIsNotNone, totalDevices=lambda x, m: self.assertEqual(x, 3, m)) self.stateCheck( self.dev16, devices=lambda x, m: self.assertEqual(len(x), 4, m), level=lambda x, m: self.assertEqual(x.number, 6, m), memberDevices=lambda x, m: self.assertEqual(x, 4, m), parents=lambda x, m: self.assertNotEqual(x, [], m), rawArraySize=lambda x, m: self.assertEqual(x, Size(spec="4 MiB"), m ), size=lambda x, m: self.assertEqual(x, Size(spec="2 MiB"), m), smallestMember=self.assertIsNotNone, totalDevices=lambda x, m: self.assertEqual(x, 4, m)) self.stateCheck( self.dev17, devices=lambda x, m: self.assertEqual(len(x), 4, m), level=lambda x, m: self.assertEqual(x.number, 10, m), memberDevices=lambda x, m: self.assertEqual(x, 4, m), parents=lambda x, m: self.assertNotEqual(x, [], m), rawArraySize=lambda x, m: self.assertEqual(x, Size(spec="4 MiB"), m ), size=lambda x, m: self.assertEqual(x, Size(spec="2 MiB"), m), smallestMember=self.assertIsNotNone, totalDevices=lambda x, m: self.assertEqual(x, 4, m)) self.stateCheck( self.dev18, devices=lambda x, m: self.assertEqual(len(x), 4, m), level=lambda x, m: self.assertEqual(x.number, 10, m), memberDevices=lambda x, m: self.assertEqual(x, 4, m), parents=lambda x, m: self.assertNotEqual(x, [], m), rawArraySize=lambda x, m: self.assertEqual(x, Size(spec="4 MiB"), m ), size=lambda x, m: self.assertEqual(x, Size(spec="2 MiB"), m), smallestMember=self.assertIsNotNone, spares=lambda x, m: self.assertEqual(x, 1, m), totalDevices=lambda x, m: self.assertEqual(x, 5, m)) self.assertRaisesRegexp(MDRaidError, "invalid RAID level", MDRaidArrayDevice, "dev") self.assertRaisesRegexp(MDRaidError, "invalid RAID level", MDRaidArrayDevice, "dev", level="raid2") self.assertRaisesRegexp( MDRaidError, "invalid RAID level", MDRaidArrayDevice, "dev", parents=[StorageDevice("parent", format=getFormat("mdmember"))]) self.assertRaisesRegexp( DeviceError, "set requires at least 2 members", MDRaidArrayDevice, "dev", level="raid0", parents=[StorageDevice("parent", format=getFormat("mdmember"))]) self.assertRaisesRegexp(MDRaidError, "invalid RAID level descriptor junk", MDRaidArrayDevice, "dev", level="junk") self.assertRaisesRegexp( ValueError, "memberDevices cannot be greater than totalDevices", MDRaidArrayDevice, "dev", level=0, memberDevices=2)
def testAddPartition(self): with sparsetmpfile("addparttest", Size("50 MiB")) as disk_file: disk = DiskFile(disk_file) disk.format = getFormat("disklabel", device=disk.path, exists=False) free = disk.format.partedDisk.getFreeSpaceRegions()[0] # # add a partition with an unaligned size # self.assertEqual(len(disk.format.partitions), 0) part = addPartition(disk.format, free, parted.PARTITION_NORMAL, Size("10 MiB") - Size(37)) self.assertEqual(len(disk.format.partitions), 1) # an unaligned size still yields an aligned partition alignment = disk.format.alignment geom = part.geometry sector_size = Size(geom.device.sectorSize) self.assertEqual(alignment.isAligned(free, geom.start), True) self.assertEqual(alignment.isAligned(free, geom.end + 1), True) self.assertEqual(part.geometry.length, int(Size("10 MiB") // sector_size)) disk.format.removePartition(part) self.assertEqual(len(disk.format.partitions), 0) # # add a partition with an unaligned start sector # start_sector = 5003 end_sector = 15001 part = addPartition(disk.format, free, parted.PARTITION_NORMAL, None, start_sector, end_sector) self.assertEqual(len(disk.format.partitions), 1) # start and end sectors are exactly as specified self.assertEqual(part.geometry.start, start_sector) self.assertEqual(part.geometry.end, end_sector) disk.format.removePartition(part) self.assertEqual(len(disk.format.partitions), 0) # # fail: add a logical partition to a primary free region # with self.assertRaisesRegex(parted.PartitionException, "no extended partition"): part = addPartition(disk.format, free, parted.PARTITION_LOGICAL, Size("10 MiB")) ## add an extended partition to the disk placeholder = addPartition(disk.format, free, parted.PARTITION_NORMAL, Size("10 MiB")) all_free = disk.format.partedDisk.getFreeSpaceRegions() addPartition(disk.format, all_free[1], parted.PARTITION_EXTENDED, Size("30 MiB"), alignment.alignUp(all_free[1], placeholder.geometry.end)) disk.format.removePartition(placeholder) self.assertEqual(len(disk.format.partitions), 1) all_free = disk.format.partedDisk.getFreeSpaceRegions() # # add a logical partition to an extended free regions # part = addPartition(disk.format, all_free[1], parted.PARTITION_LOGICAL, Size("10 MiB"), all_free[1].start) self.assertEqual(part.type, parted.PARTITION_LOGICAL) disk.format.removePartition(part) self.assertEqual(len(disk.format.partitions), 1) # # fail: add a primary partition to an extended free region # with self.assertRaisesRegex(parted.PartitionException, "overlap"): part = addPartition(disk.format, all_free[1], parted.PARTITION_NORMAL, Size("10 MiB"), all_free[1].start)
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, 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 = getFormat("biosboot") self.sda2 = PartitionDevice(name="sda2", parents=[self.sda], size=Size("500 MiB")) self.sda2.format = getFormat("mdmember") self.sda4 = PartitionDevice(name="sda4", parents=[self.sda], size=Size("500 MiB")) self.sda4.format = getFormat("btrfs") 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") self.sdb4 = PartitionDevice(name="sdb4", parents=[self.sdb], size=Size("4 GiB")) self.sdb4.format = getFormat("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 = getFormat("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", parents=[self.sda2, self.sdb2], level=1) self.boot_md.format = getFormat("ext4", mountpoint="/boot") # Set up the btrfs raid1 volume with a subvolume for /boot self.btrfs_volume = BTRFSVolumeDevice(parents=[self.sda4, self.sdb4], dataLevel=RAID1) self.btrfs_volume.format = getFormat("btrfs") self.boot_btrfs = BTRFSSubVolumeDevice(parents=[self.btrfs_volume]) self.boot_btrfs.format = getFormat("btrfs", mountpoint="/boot") self.grub = GRUB()
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): 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' )
def testTargetSize(self): with sparsetmpfile("targetsizetest", Size("10 MiB")) as disk_file: disk = DiskFile(disk_file) disk.format = getFormat("disklabel", device=disk.path) grain_size = Size(disk.format.alignment.grainSize) sector_size = Size(disk.format.partedDevice.sectorSize) start = int(grain_size) orig_size = Size("6 MiB") end = start + int(orig_size / sector_size) - 1 disk.format.addPartition(start, end) partition = disk.format.partedDisk.getPartitionBySector(start) self.assertNotEqual(partition, None) self.assertEqual(orig_size, Size(partition.getLength(unit='B'))) device = PartitionDevice(os.path.basename(partition.path), size=orig_size) device.disk = disk device.exists = True device.partedPartition = partition device.format = getFormat("ext4", device=device.path) device.format.exists = True # grain size should be 1 MiB device.format._minInstanceSize = Size("2 MiB") + (grain_size / 2) device.format._resizable = True # Make sure things are as expected to begin with. self.assertEqual(device.size, orig_size) self.assertEqual(device.minSize, Size("3 MiB")) # start sector's at 1 MiB self.assertEqual(device.maxSize, Size("9 MiB")) # ValueError if not Size with self.assertRaisesRegex(ValueError, "new size must.*type Size"): device.targetSize = 22 self.assertEqual(device.targetSize, orig_size) # ValueError if size smaller than minSize with self.assertRaisesRegex(ValueError, "size.*smaller than the minimum"): device.targetSize = Size("1 MiB") self.assertEqual(device.targetSize, orig_size) # ValueError if size larger than maxSize with self.assertRaisesRegex(ValueError, "size.*larger than the maximum"): device.targetSize = Size("11 MiB") self.assertEqual(device.targetSize, orig_size) # ValueError if unaligned with self.assertRaisesRegex(ValueError, "new size.*not.*aligned"): device.targetSize = Size("3.1 MiB") self.assertEqual(device.targetSize, orig_size) # successfully set a new target size new_target = device.maxSize device.targetSize = new_target self.assertEqual(device.targetSize, new_target) self.assertEqual(device.size, new_target) parted_size = Size(device.partedPartition.getLength(unit='B')) self.assertEqual(parted_size, device.targetSize) # reset target size to original size device.targetSize = orig_size self.assertEqual(device.targetSize, orig_size) self.assertEqual(device.size, orig_size) parted_size = Size(device.partedPartition.getLength(unit='B')) self.assertEqual(parted_size, device.targetSize)
def testMinMaxSizeAlignment(self): with sparsetmpfile("minsizetest", Size("10 MiB")) as disk_file: disk = DiskFile(disk_file) disk.format = getFormat("disklabel", device=disk.path) grain_size = Size(disk.format.alignment.grainSize) sector_size = Size(disk.format.partedDevice.sectorSize) start = int(grain_size) end = start + int(Size("6 MiB") / sector_size) disk.format.addPartition(start, end) partition = disk.format.partedDisk.getPartitionBySector(start) self.assertNotEqual(partition, None) device = PartitionDevice(os.path.basename(partition.path)) device.disk = disk device.exists = True device.partedPartition = partition # Typical sector size is 512 B. # Default optimum alignment grain size is 2048 sectors, or 1 MiB. device.format = getFormat("ext4", device=device.path) device.format.exists = True device.format._minInstanceSize = Size("2 MiB") + (grain_size / 2) device.format._resizable = True ## ## minSize ## # The end sector based only on format min size should be unaligned. min_sectors = int(device.format.minSize / sector_size) min_end_sector = partition.geometry.start + min_sectors - 1 self.assertEqual( disk.format.endAlignment.isAligned(partition.geometry, min_end_sector), False) # The end sector based on device min size should be aligned. min_sectors = int(device.minSize / sector_size) min_end_sector = partition.geometry.start + min_sectors - 1 self.assertEqual( disk.format.endAlignment.isAligned(partition.geometry, min_end_sector), True) ## ## maxSize ## # Add a partition starting three sectors past an aligned sector and # extending to the end of the disk so that there's a free region # immediately following the first partition with an unaligned end # sector. free = disk.format.partedDisk.getFreeSpaceRegions()[-1] raw_start = int(Size("9 MiB") / sector_size) start = disk.format.alignment.alignUp(free, raw_start) + 3 disk.format.addPartition(start, disk.format.partedDevice.length - 1) # Verify the end of the free region immediately following the first # partition is unaligned. free = disk.format.partedDisk.getFreeSpaceRegions()[1] self.assertEqual(disk.format.endAlignment.isAligned(free, free.end), False) # The end sector based on device min size should be aligned. max_sectors = int(device.maxSize / sector_size) max_end_sector = partition.geometry.start + max_sectors - 1 self.assertEqual( disk.format.endAlignment.isAligned(free, max_end_sector), True)
def testVGChunk(self): pv = StorageDevice("pv1", size=Size("40 GiB"), fmt=getFormat("lvmpv")) vg = LVMVolumeGroupDevice("vg", parents=[pv]) lv1 = LVMLogicalVolumeDevice("lv1", parents=[vg], size=Size("1 GiB"), grow=True) lv2 = LVMLogicalVolumeDevice("lv2", parents=[vg], size=Size("10 GiB"), grow=True) lv3 = LVMLogicalVolumeDevice("lv3", parents=[vg], size=Size("10 GiB"), grow=True, maxsize=Size("12 GiB")) req1 = LVRequest(lv1) req2 = LVRequest(lv2) req3 = LVRequest(lv3) chunk = VGChunk(vg, requests=[req1, req2, req3]) self.assertEqual(chunk.length, vg.extents) self.assertEqual(chunk.pool, vg.freeExtents) base_size = vg.align(sum((lv.size for lv in vg.lvs), Size(0)), roundup=True) base = base_size / vg.peSize self.assertEqual(chunk.base, base) # default extent size is 4 MiB self.assertEqual(chunk.lengthToSize(4), Size("16 MiB")) self.assertEqual(chunk.sizeToLength(Size("33 MiB")), 8) self.assertEqual(chunk.hasGrowable, True) self.assertEqual(chunk.remaining, 3) self.assertEqual(chunk.done, False) chunk.growRequests() # the chunk is done growing since its pool has been exhausted self.assertEqual(chunk.done, True) # there are still two requests remaining since lv1 and lv2 have no max self.assertEqual(chunk.remaining, 2) # # validate the resulting growth # # lv1 has size 1 GiB (256 extents) and is growable with no limit # lv2 has size 10 GiB (2560 extents) and is growable with no limit # lv3 has size 10 GiB (2560 extents) and is growable with a max size of # 12 GiB (max growth of 512 extents) # # The vg initially has 4863 free extents. # The growth ratio should be 1:10:10. # # The first pass through should allocate 231 extents to lv1 and 2315 # extents to each of lv2 and lv3, leaving one remaining extent, but # it should reclaim 1803 extents from lv3 since it has a maximum growth # of 512 extents (2 GiB). # # The second pass should then split up the remaining 1805 extents # between lv1 and lv2 at a ratio of 1:10, which ends up being 164 for # lv1 and 1640 for lv2. The remaining extent goes to lv2 because it is # first in the list after sorting with blivet.partitioning.lvCompare. # # Grand totals should be as follows: # lv1 should grow by 395 extents, or 1.54 GiB # lv2 should grow by 3956 extents, or 15.45 GiB # lv3 should grow by 512 extents, or 2 GiB self.assertEqual(req1.growth, 395) self.assertEqual(req2.growth, 3956) self.assertEqual(req3.growth, 512)
def testDiskChunk2(self): disk_size = Size("100 MiB") with sparsetmpfile("chunktest", disk_size) as disk_file: disk = DiskFile(disk_file) disk.format = getFormat("disklabel", device=disk.path, exists=False) p1 = PartitionDevice("p1", size=Size("10 MiB"), grow=True) p2 = PartitionDevice("p2", size=Size("30 MiB"), grow=True) # format max size should be reflected in request max growth fmt = getFormat("dummy") fmt._maxSize = Size("12 MiB") p3 = PartitionDevice("p3", size=Size("10 MiB"), grow=True, fmt=fmt) p4 = PartitionDevice("p4", size=Size("7 MiB")) # partition max size should be reflected in request max growth p5 = PartitionDevice("p5", size=Size("5 MiB"), grow=True, maxsize=Size("6 MiB")) disks = [disk] partitions = [p1, p2, p3, p4, p5] free = getFreeRegions([disk]) self.assertEqual(len(free), 1, "free region count %d not expected" % len(free)) b = Mock() allocatePartitions(b, disks, partitions, free) requests = [PartitionRequest(p) for p in partitions] chunk = DiskChunk(free[0], requests=requests) self.assertEqual(len(chunk.requests), len(partitions)) # parted reports a first free sector of 32 for disk files. whatever. length_expected = 204768 self.assertEqual(chunk.length, length_expected) growable = [p for p in partitions if p.req_grow] fixed = [p for p in partitions if not p.req_grow] base_expected = sum(p.partedPartition.geometry.length for p in growable) self.assertEqual(chunk.base, base_expected) base_fixed = sum(p.partedPartition.geometry.length for p in fixed) pool_expected = chunk.length - base_expected - base_fixed self.assertEqual(chunk.pool, pool_expected) self.assertEqual(chunk.done, False) # since p5 is not growable it is initially done self.assertEqual(chunk.remaining, 4) chunk.growRequests() # # validate the growth (in sectors) # # The chunk length is 204768. # Request bases: # p1 20480 # p2 61440 # p3 20480 # p4 14336 (not included in chunk base since it isn't growable) # p5 10240 # # The chunk has a base 112640 and a pool of 77792. # # Request max growth: # p1 0 # p2 0 # p3 4096 # p4 0 # p5 2048 # # The first round should allocate to p1, p2, p3, p5 at a ratio of # 2:6:2:1, which is 14144, 42432, 14144, 7072. Due to max growth, # p3 and p5 will be limited and the extra (10048, 5024) will remain # in the pool. In the second round the remaining requests will be # p1 and p2. They will divide up the pool of 15072 at a ratio of # 1:3, which is 3768 and 11304. At this point the pool should be # empty. # # Total growth: # p1 17912 # p2 53736 # p3 4096 # p4 0 # p5 2048 # self.assertEqual(chunk.done, True) self.assertEqual(chunk.pool, 0) self.assertEqual(chunk.remaining, 2) # p1, p2 have no max # chunk.requests got sorted, so use the list whose order we know self.assertEqual(requests[0].growth, 17912) self.assertEqual(requests[1].growth, 53736) self.assertEqual(requests[2].growth, 4096) self.assertEqual(requests[3].growth, 0) self.assertEqual(requests[4].growth, 2048)
def setUp(self): self._state_functions = { "createBitmap" : self.assertTrue, "currentSize" : lambda x, m: self.assertEqual(x, Size(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(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, "resizable" : self.assertFalse, "size" : lambda x, m: self.assertEqual(x, Size(0), m), "spares" : lambda x, m: self.assertEqual(x, 0, m), "status" : self.assertFalse, "sysfsPath" : lambda x, m: self.assertEqual(x, "", m), "targetSize" : lambda x, m: self.assertEqual(x, Size(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", fmt=getFormat("mdmember")), MDRaidArrayDevice("other", level=0, fmt=getFormat("mdmember"))], totalDevices=2) self.dev10 = MDRaidArrayDevice( "dev10", level="raid0", size=Size("32 MiB")) self.dev11 = MDRaidArrayDevice( "dev11", level=1, memberDevices=2, parents=[ MDRaidArrayDevice("parent", level="container", fmt=getFormat("mdmember")), MDRaidArrayDevice("other", level="raid0", fmt=getFormat("mdmember"))], size=Size("32 MiB"), totalDevices=2) self.dev12 = MDRaidArrayDevice( "dev12", level=1, memberDevices=2, parents=[ Mock(**{"type": "mdcontainer", "size": Size("4 MiB"), "format": getFormat("mdmember")}), 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)