def arm_efi_test(self, arch):
"""Test the ARM EFI platform."""
self._reset_arch(arch)
arch.is_efi.return_value = True
arch.is_aarch64.return_value = True
self._check_platform(
platform_cls=Aarch64EFI,
non_linux_format_types=["vfat", "ntfs"]
)
self._check_partitions(
PartSpec(mountpoint="/boot/efi", fstype="efi", grow=True,
size=Size("200MiB"), max_size=Size("600MiB")),
PartSpec(mountpoint="/boot", size=Size("1GiB"))
)
self._check_constraints(
constraints={
"format_types": ["efi"],
"device_types": ["partition", "mdarray"],
"mountpoints": ["/boot/efi"],
"raid_levels": [raid.RAID1],
"raid_metadata": ["1.0"]
},
descriptions={
"partition": "EFI System Partition",
"mdarray": "RAID Device"
},
error_message=str(
"For a UEFI installation, you must include "
"an EFI System Partition on a GPT-formatted "
"disk, mounted at /boot/efi."
)
)
def pseries_ppc_test(self, arch):
"""Test the pSeries PPC platform."""
self._reset_arch(arch)
arch.is_ppc.return_value = True
arch.get_ppc_machine.return_value = "pSeries"
self._check_platform(
platform_cls=IPSeriesPPC
)
self._check_partitions(
PartSpec(fstype="prepboot", size=Size("4MiB")),
PartSpec(mountpoint="/boot", size=Size("1GiB"))
)
self._check_constraints(
constraints={
"device_types": ["partition"],
"format_types": ["prepboot"],
"max_end": Size("4 GiB")
},
descriptions={
"partition": "PReP Boot Partition"
},
error_message=str(
"You must include a PReP Boot Partition "
"within the first 4GiB of an MBR- "
"or GPT-formatted disk."
)
)
def new_world_ppc_test(self, arch):
"""Test the New World PPC platform."""
self._reset_arch(arch)
arch.is_ppc.return_value = True
arch.get_ppc_machine.return_value = "PMac"
arch.get_ppc_mac_gen.return_value = "NewWorld"
self._check_platform(
platform_cls=NewWorldPPC,
non_linux_format_types=["hfs", "hfs+"]
)
self._check_partitions(
PartSpec(fstype="appleboot", size=Size("1MiB")),
PartSpec(mountpoint="/boot", size=Size("1GiB"))
)
self._check_constraints(
constraints={
"device_types": ["partition"],
"format_types": ["appleboot"],
},
descriptions={
"partition": "Apple Bootstrap Partition"
},
error_message=str(
"You must include an Apple Bootstrap "
"Partition on an Apple Partition Map-"
"formatted disk."
)
)
def x86_test(self, arch):
"""Test the x86 platform."""
self._reset_arch(arch)
arch.is_x86.return_value = True
self._check_platform(
platform_cls=X86,
non_linux_format_types=["vfat", "ntfs", "hpfs"],
)
self._check_partitions(
PartSpec(fstype="biosboot", size=Size("1MiB")),
PartSpec(mountpoint="/boot", size=Size("1GiB")),
)
self._check_constraints(
constraints={
"device_types": ["disk"],
},
descriptions={
"disk": "Master Boot Record",
"partition": "First sector of boot partition",
"mdarray": "RAID Device"
},
error_message=str(
"You must include at least one MBR- or "
"GPT-formatted disk as an install target."
)
)
def get_default_partitioning():
"""Get the default partitioning requests.
:return: a list of partitioning specs
"""
# Get the platform-specific partitioning.
partitioning = list(platform.set_default_partitioning())
# Get the product-specific partitioning.
for attrs in conf.storage.default_partitioning:
name = attrs.get("name")
swap = name == "swap"
spec = PartSpec(
mountpoint=name if not swap else None,
fstype=None if not swap else "swap",
lv=True,
thin=not swap,
btr=not swap,
size=attrs.get("min") or attrs.get("size"),
max_size=attrs.get("max"),
grow="min" in attrs,
required_space=attrs.get("free") or 0,
encrypted=attrs.get("encrypted") or False,
)
partitioning.append(spec)
return partitioning
def arm_test(self, arch):
"""Test the ARM platform."""
self._reset_arch(arch)
arch.is_arm.return_value = True
self._check_platform(
platform_cls=ARM
)
self._check_partitions(
PartSpec(mountpoint="/boot", size=Size("1GiB"))
)
self._check_constraints(
constraints={
"device_types": ["disk"]
},
descriptions={
"disk": "Master Boot Record",
"partition": "First sector of boot partition",
},
error_message=str(
"You must include at least one MBR-formatted "
"disk as an install target."
)
)
def power_nv_ppc_test(self, arch):
"""Test the Power NV PPC platform."""
self._reset_arch(arch)
arch.is_ppc.return_value = True
arch.get_ppc_machine.return_value = "PowerNV"
self._check_platform(
platform_cls=PowerNV
)
self._check_partitions(
PartSpec(mountpoint="/boot", size=Size("1GiB"))
)
self._check_constraints(
constraints={
"device_types": ["partition"],
},
descriptions={
"partition": "First sector of boot partition"
},
error_message=str(
"You must include at least one disk as an install target."
)
)
def _boot_partition(self):
"""The default /boot partition for this platform."""
return PartSpec(
mountpoint="/boot",
size=Size("1GiB"),
lv=False
)
def test_get_partitioning(self, platform, suggest_swap_size):
storage = create_storage()
# Set the platform specs.
platform.partitions = [PartSpec(mountpoint="/boot", size=Size("1GiB"))]
# Set the file system type for /boot.
storage._bootloader = Mock(stage2_format_types=["xfs"])
# Set the swap size.
suggest_swap_size.return_value = Size("1024MiB")
# Collect the requests.
requests = AutomaticPartitioningTask._get_partitioning(
storage=storage, excluded_mount_points=["/home", "/boot", "swap"])
assert ["/"] == [spec.mountpoint for spec in requests]
requests = AutomaticPartitioningTask._get_partitioning(
storage=storage, excluded_mount_points=[])
assert ["/boot", "/", "/home"] == \
[spec.mountpoint for spec in requests]
assert ["xfs", "ext4", "ext4"] == \
[spec.fstype for spec in requests]
assert [Size("1GiB"), Size("1GiB"), Size("500MiB")] == \
[spec.size for spec in requests]
def s390x_test(self, arch):
"""Test the s390x platform."""
self._reset_arch(arch)
arch.is_s390.return_value = True
self._check_platform(
platform_cls=S390
)
self._check_partitions(
PartSpec(mountpoint="/boot", size=Size("1GiB"), lv=False),
)
self._check_constraints(
constraints={
"device_types": ["disk", "partition"],
},
descriptions={
"dasd": "DASD",
"zfcp": "zFCP",
"disk": "Master Boot Record",
"partition": "First sector of boot partition"
},
error_message=str(
"You must include at least one MBR- or "
"DASD-formatted disk as an install target."
)
)
def _bootloader_partition(self):
"""The default bootloader partition for this platform."""
return PartSpec(
mountpoint="/boot/efi",
fstype="macefi",
size=Size("200MiB"),
max_size=Size("600MiB"),
grow=True,
)
def set_platform_bootloader_reqs(self):
ret = super().set_platform_bootloader_reqs()
ret.append(
PartSpec(mountpoint="/boot/efi",
fstype="macefi",
size=Size("200MiB"),
max_size=Size("600MiB"),
grow=True))
return ret
def _boot_partition(self):
"""The default /boot partition for this platform.
:return: a specification or None
"""
return PartSpec(
mountpoint="/boot",
size=Size("1GiB")
)
def get_default_partitioning_test(self, platform):
platform.set_default_partitioning.return_value = [PartSpec("/boot")]
requests = get_default_partitioning(PartitioningType.WORKSTATION)
self.assertEqual(["/boot", "/", "/home", None],
[spec.mountpoint for spec in requests])
requests = get_default_partitioning(PartitioningType.SERVER)
self.assertEqual(["/boot", "/", None],
[spec.mountpoint for spec in requests])
def test_is_partition(self):
"""Test the is_partition method."""
spec = PartSpec("/")
assert spec.is_partition(AUTOPART_TYPE_PLAIN) == True
assert spec.is_partition(AUTOPART_TYPE_LVM) == True
assert spec.is_partition(AUTOPART_TYPE_LVM_THINP) == True
assert spec.is_partition(AUTOPART_TYPE_BTRFS) == True
def is_partition_test(self):
"""Test the is_partition method."""
spec = PartSpec("/")
self.assertEqual(spec.is_partition(AUTOPART_TYPE_PLAIN), True)
self.assertEqual(spec.is_partition(AUTOPART_TYPE_LVM), True)
self.assertEqual(spec.is_partition(AUTOPART_TYPE_LVM_THINP), True)
self.assertEqual(spec.is_partition(AUTOPART_TYPE_BTRFS), True)
def mac_efi_test(self, arch):
"""Test the Mac EFI platform."""
self._reset_arch(arch)
arch.is_efi.return_value = True
arch.is_mactel.return_value = True
self._check_platform(
platform_cls=MacEFI,
packages=["mactel-boot"],
non_linux_format_types=["macefi"],
)
self._check_partitions(
PartSpec(mountpoint="/boot/efi", fstype="macefi", grow=True,
size=Size("200MiB"), max_size=Size("600MiB")),
PartSpec(mountpoint="/boot", size=Size("1GiB")),
)
self._check_constraints(
constraints={
"format_types": ["macefi"],
"device_types": ["partition", "mdarray"],
"mountpoints": ["/boot/efi"],
"raid_levels": [raid.RAID1],
"raid_metadata": ["1.0"]
},
descriptions={
"partition": "Apple EFI Boot Partition",
"mdarray": "RAID Device"
},
error_message=str(
"For a UEFI installation, you must include "
"a Linux HFS+ ESP on a GPT-formatted "
"disk, mounted at /boot/efi."
)
)
def test_get_disks_for_implicit_partitions(self):
"""Test the get_disks_for_implicit_partitions function."""
# The /boot partition always requires a slot.
requests = [
PartSpec(mountpoint="/boot", size=Size("1GiB")),
PartSpec(mountpoint="/",
size=Size("2GiB"),
max_size=Size("15GiB"),
grow=True,
btr=True,
lv=True,
thin=True,
encrypted=True),
PartSpec(fstype="swap", grow=False, lv=True, encrypted=True)
]
# No implicit partitions to schedule.
disk_1 = Mock()
disk_2 = Mock()
parted_disk_1 = disk_1.format.parted_disk
parted_disk_2 = disk_2.format.parted_disk
assert get_disks_for_implicit_partitions(
scheme=AUTOPART_TYPE_PLAIN,
disks=[disk_1, disk_2],
requests=requests
) == \
[]
# Extended partitions are supported by the first disk.
parted_disk_1.supportsFeature.return_value = True
parted_disk_1.maxPrimaryPartitionCount = 3
parted_disk_1.primaryPartitionCount = 3
parted_disk_2.supportsFeature.return_value = False
parted_disk_2.maxPrimaryPartitionCount = 3
parted_disk_2.primaryPartitionCount = 2
assert get_disks_for_implicit_partitions(
scheme=AUTOPART_TYPE_LVM_THINP,
disks=[disk_1, disk_2],
requests=requests
) == \
[disk_1, disk_2]
# Extended partitions are not supported by the first disk.
parted_disk_1.supportsFeature.return_value = False
parted_disk_1.maxPrimaryPartitionCount = 3
parted_disk_1.primaryPartitionCount = 2
assert get_disks_for_implicit_partitions(
scheme=AUTOPART_TYPE_LVM_THINP,
disks=[disk_1, disk_2],
requests=requests
) == \
[disk_2]
# Not empty slots for implicit partitions.
parted_disk_1.supportsFeature.return_value = False
parted_disk_1.maxPrimaryPartitionCount = 3
parted_disk_1.primaryPartitionCount = 3
assert get_disks_for_implicit_partitions(
scheme=AUTOPART_TYPE_LVM_THINP,
disks=[disk_1, disk_2],
requests=requests
) == \
[]
def _bootloader_partition(self):
"""The default bootloader partition for this platform."""
return PartSpec(
fstype="appleboot",
size=Size("1MiB")
)
def test_get_default_partitioning(self, platform):
platform.partitions = [PartSpec("/boot")]
requests = get_default_partitioning()
assert ["/boot", "/",
"/home"] == [spec.mountpoint for spec in requests]
from pyanaconda.modules.storage.partitioning.automatic.utils import get_default_partitioning
from pyanaconda.modules.storage.partitioning.specification import PartSpec
from pyanaconda.core.configuration.anaconda import AnacondaConfiguration
from pyanaconda.core.configuration.base import ConfigurationError, create_parser, read_config
from pyanaconda.core.configuration.product import ProductLoader
from pyanaconda.product import trim_product_version_for_ui
PRODUCT_DIR = os.path.join(os.environ.get("ANACONDA_DATA"), "product.d")
SERVER_PARTITIONING = [
PartSpec(
mountpoint="/",
size=Size("2GiB"),
max_size=Size("15GiB"),
grow=True,
btr=True,
lv=True,
thin=True,
encrypted=True,
)
]
WORKSTATION_PARTITIONING = [
PartSpec(
mountpoint="/",
size=Size("1GiB"),
max_size=Size("70GiB"),
grow=True,
btr=True,
lv=True,
thin=True,
def get_default_partitioning_test(self, platform):
platform.partitions = [PartSpec("/boot")]
requests = get_default_partitioning()
self.assertEqual(["/boot", "/", "/home"],
[spec.mountpoint for spec in requests])
def test_is_lvm_thin_volume(self):
"""Test the is_lvm_thin_volume method."""
spec = PartSpec("/", lv=True)
assert spec.is_lvm_thin_volume(AUTOPART_TYPE_PLAIN) == False
assert spec.is_lvm_thin_volume(AUTOPART_TYPE_LVM) == False
assert spec.is_lvm_thin_volume(AUTOPART_TYPE_LVM_THINP) == False
assert spec.is_lvm_thin_volume(AUTOPART_TYPE_BTRFS) == False
spec = PartSpec("/", lv=True, thin=True)
assert spec.is_lvm_thin_volume(AUTOPART_TYPE_PLAIN) == False
assert spec.is_lvm_thin_volume(AUTOPART_TYPE_LVM) == False
assert spec.is_lvm_thin_volume(AUTOPART_TYPE_LVM_THINP) == True
assert spec.is_lvm_thin_volume(AUTOPART_TYPE_BTRFS) == False
def set_platform_boot_partition(self):
"""Return the default /boot partition for this platform."""
return [PartSpec(mountpoint="/boot", size=Size("1GiB"))]
def set_platform_bootloader_reqs(self):
"""Return the default platform-specific partitioning information."""
ret = super().set_platform_bootloader_reqs()
ret.append(PartSpec(fstype="biosboot", size=Size("1MiB")))
return ret
def set_platform_bootloader_reqs(self):
ret = PPC.set_platform_bootloader_reqs(self)
ret.append(PartSpec(fstype="prepboot", size=Size("4MiB")))
return ret
def set_platform_bootloader_reqs(self):
ret = super().set_platform_bootloader_reqs()
ret.append(PartSpec(fstype="appleboot", size=Size("1MiB")))
return ret
def set_platform_boot_partition(self):
"""Return the default platform-specific partitioning information."""
return [PartSpec(mountpoint="/boot", size=Size("1GiB"), lv=False)]
def is_lvm_thin_volume_test(self):
"""Test the is_lvm_thin_volume method."""
spec = PartSpec("/", lv=True)
self.assertEqual(spec.is_lvm_thin_volume(AUTOPART_TYPE_PLAIN), False)
self.assertEqual(spec.is_lvm_thin_volume(AUTOPART_TYPE_LVM), False)
self.assertEqual(spec.is_lvm_thin_volume(AUTOPART_TYPE_LVM_THINP),
False)
self.assertEqual(spec.is_lvm_thin_volume(AUTOPART_TYPE_BTRFS), False)
spec = PartSpec("/", lv=True, thin=True)
self.assertEqual(spec.is_lvm_thin_volume(AUTOPART_TYPE_PLAIN), False)
self.assertEqual(spec.is_lvm_thin_volume(AUTOPART_TYPE_LVM), False)
self.assertEqual(spec.is_lvm_thin_volume(AUTOPART_TYPE_LVM_THINP),
True)
self.assertEqual(spec.is_lvm_thin_volume(AUTOPART_TYPE_BTRFS), False)
