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 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 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):
"""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 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)
