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