class TestFileSystemSquashfs:
@patch('os.path.exists')
def setup(self, mock_exists):
mock_exists.return_value = True
self.squashfs = FileSystemSquashFs(mock.Mock(), 'root_dir')
@patch('os.path.exists')
def setup_method(self, cls, mock_exists):
self.setup()
@patch('kiwi.filesystem.squashfs.Command.run')
def test_create_on_file(self, mock_command):
Defaults.set_platform_name('x86_64')
self.squashfs.create_on_file('myimage', 'label')
mock_command.assert_called_once_with([
'mksquashfs', 'root_dir', 'myimage', '-noappend', '-b', '1M',
'-comp', 'xz', '-Xbcj', 'x86'
])
@patch('kiwi.filesystem.squashfs.Command.run')
def test_create_on_file_exclude_data(self, mock_command):
Defaults.set_platform_name('ppc64le')
self.squashfs.create_on_file('myimage', 'label', ['foo'])
mock_command.assert_called_once_with([
'mksquashfs', 'root_dir', 'myimage', '-noappend', '-b', '1M',
'-comp', 'xz', '-Xbcj', 'powerpc', '-wildcards', '-e', 'foo'
])
@patch('kiwi.filesystem.squashfs.Command.run')
def test_create_on_file_unkown_arch(self, mock_command):
Defaults.set_platform_name('aarch64')
self.squashfs.create_on_file('myimage', 'label')
mock_command.assert_called_once_with([
'mksquashfs', 'root_dir', 'myimage', '-noappend', '-b', '1M',
'-comp', 'xz'
])
@patch('kiwi.filesystem.squashfs.Command.run')
def test_create_on_file_gzip(self, mock_command):
self.squashfs.custom_args = {
'compression': 'gzip',
'create_options': []
}
self.squashfs.create_on_file('myimage', 'label')
mock_command.assert_called_once_with([
'mksquashfs', 'root_dir', 'myimage', '-noappend', '-b', '1M',
'-comp', 'gzip'
])
@patch('kiwi.filesystem.squashfs.Command.run')
def test_create_on_file_no_compression(self, mock_command):
self.squashfs.custom_args = {
'compression': 'uncompressed',
'create_options': []
}
self.squashfs.create_on_file('myimage', 'label')
mock_command.assert_called_once_with([
'mksquashfs', 'root_dir', 'myimage', '-noappend', '-b', '1M',
'-noI', '-noD', '-noF', '-noX'
])
def _sync_system_to_image(self, device_map):
log.info('Syncing system to image')
if self.system_spare:
self.system_spare.sync_data()
if self.system_efi:
log.info('--> Syncing EFI boot data to EFI partition')
self.system_efi.sync_data()
if self.system_boot:
log.info('--> Syncing boot data at extra partition')
self.system_boot.sync_data(
self._get_exclude_list_for_boot_data_sync())
log.info('--> Syncing root filesystem data')
if self.root_filesystem_is_overlay:
squashed_root_file = NamedTemporaryFile()
squashed_root = FileSystemSquashFs(
device_provider=None,
root_dir=self.root_dir,
custom_args={
'compression':
self.xml_state.build_type.get_squashfscompression()
})
squashed_root.create_on_file(
filename=squashed_root_file.name,
exclude=self._get_exclude_list_for_root_data_sync(device_map))
Command.run([
'dd',
'if=%s' % squashed_root_file.name,
'of=%s' % device_map['readonly'].get_device()
])
else:
self.system.sync_data(
self._get_exclude_list_for_root_data_sync(device_map))
class TestFileSystemSquashfs(object):
@patch('os.path.exists')
def setup(self, mock_exists):
mock_exists.return_value = True
self.squashfs = FileSystemSquashFs(mock.Mock(), 'root_dir')
@patch('kiwi.filesystem.squashfs.Command.run')
def test_create_on_file(self, mock_command):
self.squashfs.create_on_file('myimage', 'label')
mock_command.assert_called_once_with(
['mksquashfs', 'root_dir', 'myimage']
)
def _sync_system_to_image(
self, device_map: Dict, system: Any,
system_boot: Optional[FileSystemBase],
system_efi: Optional[FileSystemBase],
system_spare: Optional[FileSystemBase],
system_custom_parts: List[FileSystemBase]) -> None:
log.info('Syncing system to image')
if system_spare:
log.info('--> Syncing spare partition data')
system_spare.sync_data()
for system_custom_part in system_custom_parts:
log.info('--> Syncing custom partition(s) data')
system_custom_part.sync_data()
if system_efi:
log.info('--> Syncing EFI boot data to EFI partition')
system_efi.sync_data()
if system_boot:
log.info('--> Syncing boot data at extra partition')
system_boot.sync_data(self._get_exclude_list_for_boot_data_sync())
log.info('--> Syncing root filesystem data')
if self.root_filesystem_is_overlay:
squashed_root_file = Temporary().new_file()
squashed_root = FileSystemSquashFs(
device_provider=DeviceProvider(),
root_dir=self.root_dir,
custom_args={
'compression':
self.xml_state.build_type.get_squashfscompression()
})
squashed_root.create_on_file(
filename=squashed_root_file.name,
exclude=self._get_exclude_list_for_root_data_sync(device_map))
Command.run([
'dd',
'if=%s' % squashed_root_file.name,
'of=%s' % device_map['readonly'].get_device()
])
else:
system.sync_data(
self._get_exclude_list_for_root_data_sync(device_map))
class TestFileSystemSquashfs(object):
@patch('os.path.exists')
def setup(self, mock_exists):
mock_exists.return_value = True
self.squashfs = FileSystemSquashFs(mock.Mock(), 'root_dir')
@patch('kiwi.filesystem.squashfs.Command.run')
def test_create_on_file(self, mock_command):
self.squashfs.create_on_file('myimage', 'label')
mock_command.assert_called_once_with(
['mksquashfs', 'root_dir', 'myimage', '-noappend', '-comp', 'xz'])
@patch('kiwi.filesystem.squashfs.Command.run')
def test_create_on_file_exclude_data(self, mock_command):
self.squashfs.create_on_file('myimage', 'label', ['foo'])
mock_command.assert_called_once_with([
'mksquashfs', 'root_dir', 'myimage', '-noappend', '-comp', 'xz',
'-e', 'foo'
])
class TestFileSystemSquashfs:
@patch('os.path.exists')
def setup(self, mock_exists):
mock_exists.return_value = True
self.squashfs = FileSystemSquashFs(mock.Mock(), 'root_dir')
@patch('platform.machine')
@patch('kiwi.filesystem.squashfs.Command.run')
def test_create_on_file(self, mock_command, mock_machine):
mock_machine.return_value = 'x86_64'
self.squashfs.create_on_file('myimage', 'label')
mock_command.assert_called_once_with([
'mksquashfs', 'root_dir', 'myimage', '-noappend', '-b', '1M',
'-comp', 'xz', '-Xbcj', 'x86'
])
@patch('platform.machine')
@patch('kiwi.filesystem.squashfs.Command.run')
def test_create_on_file_exclude_data(self, mock_command, mock_machine):
mock_machine.return_value = 'ppc64le'
self.squashfs.create_on_file('myimage', 'label', ['foo'])
mock_command.assert_called_once_with([
'mksquashfs', 'root_dir', 'myimage', '-noappend', '-b', '1M',
'-comp', 'xz', '-Xbcj', 'powerpc', '-wildcards', '-e', 'foo'
])
@patch('platform.machine')
@patch('kiwi.filesystem.squashfs.Command.run')
def test_create_on_file_unkown_arch(self, mock_command, mock_machine):
mock_machine.return_value = 'aarch64'
self.squashfs.create_on_file('myimage', 'label')
mock_command.assert_called_once_with([
'mksquashfs', 'root_dir', 'myimage', '-noappend', '-b', '1M',
'-comp', 'xz'
])
def __new__(self, name, device_provider, root_dir=None, custom_args=None):
if name == 'ext2':
return FileSystemExt2(device_provider, root_dir, custom_args)
elif name == 'ext3':
return FileSystemExt3(device_provider, root_dir, custom_args)
elif name == 'ext4':
return FileSystemExt4(device_provider, root_dir, custom_args)
elif name == 'btrfs':
return FileSystemBtrfs(device_provider, root_dir, custom_args)
elif name == 'xfs':
return FileSystemXfs(device_provider, root_dir, custom_args)
elif name == 'fat16':
return FileSystemFat16(device_provider, root_dir, custom_args)
elif name == 'fat32':
return FileSystemFat32(device_provider, root_dir, custom_args)
elif name == 'squashfs':
return FileSystemSquashFs(device_provider, root_dir, custom_args)
elif name == 'clicfs':
return FileSystemClicFs(device_provider, root_dir, custom_args)
elif name == 'swap':
return FileSystemSwap(device_provider, root_dir, custom_args)
else:
raise KiwiFileSystemSetupError(
'Support for %s filesystem not implemented' % name)
class TestFileSystemSquashfs(object):
@patch('os.path.exists')
def setup(self, mock_exists):
mock_exists.return_value = True
self.squashfs = FileSystemSquashFs(mock.Mock(), 'root_dir')
@patch('platform.machine')
@patch('kiwi.filesystem.squashfs.Command.run')
def test_create_on_file(self, mock_command, mock_machine):
mock_machine.return_value = 'x86_64'
self.squashfs.create_on_file('myimage', 'label')
mock_command.assert_called_once_with(
[
'mksquashfs', 'root_dir', 'myimage', '-noappend',
'-b', '1M', '-comp', 'xz', '-Xbcj', 'x86'
]
)
@patch('platform.machine')
@patch('kiwi.filesystem.squashfs.Command.run')
def test_create_on_file_exclude_data(self, mock_command, mock_machine):
mock_machine.return_value = 'ppc64le'
self.squashfs.create_on_file('myimage', 'label', ['foo'])
mock_command.assert_called_once_with(
[
'mksquashfs', 'root_dir', 'myimage', '-noappend',
'-b', '1M', '-comp', 'xz', '-Xbcj', 'powerpc', '-e', 'foo'
]
)
@patch('platform.machine')
@patch('kiwi.filesystem.squashfs.Command.run')
def test_create_on_file_unkown_arch(self, mock_command, mock_machine):
mock_machine.return_value = 'aarch64'
self.squashfs.create_on_file('myimage', 'label')
mock_command.assert_called_once_with(
[
'mksquashfs', 'root_dir', 'myimage',
'-noappend', '-b', '1M', '-comp', 'xz'
]
)
def setup(self, mock_exists):
mock_exists.return_value = True
self.squashfs = FileSystemSquashFs(mock.Mock(), 'root_dir')
def create_install_iso(self):
"""
Create an install ISO from the disk_image as hybrid ISO
bootable via legacy BIOS, EFI and as disk from Stick
Image types which triggers this builder are:
* installiso="true|false"
* installstick="true|false"
"""
self.media_dir = mkdtemp(prefix='kiwi_install_media.',
dir=self.target_dir)
# unpack cdroot user files to media dir
self.setup.import_cdroot_files(self.media_dir)
# custom iso metadata
self.custom_iso_args = {
'meta_data': {
'volume_id': Defaults.get_install_volume_id(),
'mbr_id': self.mbrid.get_id(),
'efi_mode': self.firmware.efi_mode()
}
}
# the system image transfer is checked against a checksum
log.info('Creating disk image checksum')
self.squashed_contents = mkdtemp(prefix='kiwi_install_squashfs.',
dir=self.target_dir)
checksum = Checksum(self.diskname)
checksum.md5(self.squashed_contents + '/' + self.md5name)
# the system image name is stored in a config file
self._write_install_image_info_to_iso_image()
if self.initrd_system == 'kiwi':
self._write_install_image_info_to_boot_image()
# the system image is stored as squashfs embedded file
log.info('Creating squashfs embedded disk image')
Command.run([
'cp', '-l', self.diskname,
self.squashed_contents + '/' + self.squashed_diskname
])
squashed_image_file = ''.join(
[self.target_dir, '/', self.squashed_diskname, '.squashfs'])
squashed_image = FileSystemSquashFs(device_provider=None,
root_dir=self.squashed_contents)
squashed_image.create_on_file(squashed_image_file)
Command.run(['mv', squashed_image_file, self.media_dir])
# setup bootloader config to boot the ISO via isolinux
log.info('Setting up install image bootloader configuration')
bootloader_config_isolinux = BootLoaderConfig('isolinux',
self.xml_state,
self.media_dir)
bootloader_config_isolinux.setup_install_boot_images(
mbrid=None, lookup_path=self.boot_image_task.boot_root_directory)
bootloader_config_isolinux.setup_install_image_config(mbrid=None)
bootloader_config_isolinux.write()
# setup bootloader config to boot the ISO via EFI
bootloader_config_grub = BootLoaderConfig(
'grub2', self.xml_state, self.media_dir, {
'grub_directory_name':
Defaults.get_grub_boot_directory_name(self.root_dir)
})
bootloader_config_grub.setup_install_boot_images(
mbrid=self.mbrid, lookup_path=self.root_dir)
bootloader_config_grub.setup_install_image_config(mbrid=self.mbrid)
bootloader_config_grub.write()
# create initrd for install image
log.info('Creating install image boot image')
self._create_iso_install_kernel_and_initrd()
# the system image initrd is stored to allow kexec
self._copy_system_image_initrd_to_iso_image()
# create iso filesystem from media_dir
log.info('Creating ISO filesystem')
iso_image = FileSystemIsoFs(device_provider=None,
root_dir=self.media_dir,
custom_args=self.custom_iso_args)
iso_image.create_on_file(self.isoname)
def create_disk(self):
"""
Build a bootable raw disk image
:raises KiwiInstallMediaError:
if install media is required and image type is not oem
:raises KiwiVolumeManagerSetupError:
root overlay at the same time volumes are defined is not supported
:return: result
:rtype: instance of :class:`Result`
"""
if self.install_media and self.build_type_name != 'oem':
raise KiwiInstallMediaError(
'Install media requires oem type setup, got %s' %
self.build_type_name
)
if self.root_filesystem_is_overlay and self.volume_manager_name:
raise KiwiVolumeManagerSetupError(
'Volume management together with root overlay is not supported'
)
# setup recovery archive, cleanup and create archive if requested
self.system_setup.create_recovery_archive()
# prepare boot(initrd) root system
log.info('Preparing boot system')
self.boot_image.prepare()
# precalculate needed disk size
disksize_mbytes = self.disk_setup.get_disksize_mbytes()
# create the disk
log.info('Creating raw disk image %s', self.diskname)
loop_provider = LoopDevice(
self.diskname, disksize_mbytes, self.blocksize
)
loop_provider.create()
self.disk = Disk(
self.firmware.get_partition_table_type(), loop_provider,
self.xml_state.get_disk_start_sector()
)
# create the bootloader instance
self.bootloader_config = BootLoaderConfig(
self.bootloader, self.xml_state, self.root_dir, {
'targetbase':
loop_provider.get_device(),
'grub_directory_name':
Defaults.get_grub_boot_directory_name(self.root_dir)
}
)
# create disk partitions and instance device map
device_map = self._build_and_map_disk_partitions()
# create raid on current root device if requested
if self.mdraid:
self.raid_root = RaidDevice(device_map['root'])
self.raid_root.create_degraded_raid(raid_level=self.mdraid)
device_map['root'] = self.raid_root.get_device()
self.disk.public_partition_id_map['kiwi_RaidPart'] = \
self.disk.public_partition_id_map['kiwi_RootPart']
self.disk.public_partition_id_map['kiwi_RaidDev'] = \
device_map['root'].get_device()
# create luks on current root device if requested
if self.luks:
self.luks_root = LuksDevice(device_map['root'])
self.luks_root.create_crypto_luks(
passphrase=self.luks, os=self.luks_os
)
device_map['root'] = self.luks_root.get_device()
# create filesystems on boot partition(s) if any
self._build_boot_filesystems(device_map)
# create volumes and filesystems for root system
if self.volume_manager_name:
volume_manager_custom_parameters = {
'fs_mount_options':
self.custom_root_mount_args,
'root_label':
self.disk_setup.get_root_label(),
'root_is_snapshot':
self.xml_state.build_type.get_btrfs_root_is_snapshot(),
'root_is_readonly_snapshot':
self.xml_state.build_type.get_btrfs_root_is_readonly_snapshot(),
'image_type':
self.xml_state.get_build_type_name()
}
volume_manager = VolumeManager(
self.volume_manager_name, device_map['root'],
self.root_dir + '/',
self.volumes,
volume_manager_custom_parameters
)
volume_manager.setup(
self.volume_group_name
)
volume_manager.create_volumes(
self.requested_filesystem
)
volume_manager.mount_volumes()
self.generic_fstab_entries += volume_manager.get_fstab(
self.persistency_type, self.requested_filesystem
)
self.system = volume_manager
device_map['root'] = volume_manager.get_device()['root']
else:
log.info(
'Creating root(%s) filesystem on %s',
self.requested_filesystem, device_map['root'].get_device()
)
filesystem_custom_parameters = {
'mount_options': self.custom_root_mount_args
}
filesystem = FileSystem(
self.requested_filesystem, device_map['root'],
self.root_dir + '/',
filesystem_custom_parameters
)
filesystem.create_on_device(
label=self.disk_setup.get_root_label()
)
self.system = filesystem
# create a random image identifier
self.mbrid = SystemIdentifier()
self.mbrid.calculate_id()
# create first stage metadata to boot image
self._write_partition_id_config_to_boot_image()
self._write_recovery_metadata_to_boot_image()
self._write_raid_config_to_boot_image()
self._write_generic_fstab_to_boot_image(device_map)
self.system_setup.export_modprobe_setup(
self.boot_image.boot_root_directory
)
# create first stage metadata to system image
self._write_image_identifier_to_system_image()
self._write_crypttab_to_system_image()
self._write_generic_fstab_to_system_image(device_map)
if self.initrd_system == 'dracut':
self._create_dracut_config()
# create initrd cpio archive
self.boot_image.create_initrd(self.mbrid)
# create dracut config omitting one time kiwi dracut modules
if self.initrd_system == 'dracut':
self._create_system_dracut_config()
# create second stage metadata to system image
self._copy_first_boot_files_to_system_image()
self._write_bootloader_config_to_system_image(device_map)
self.mbrid.write_to_disk(
self.disk.storage_provider
)
# set SELinux file security contexts if context exists
self._setup_selinux_file_contexts()
# syncing system data to disk image
log.info('Syncing system to image')
if self.system_efi:
log.info('--> Syncing EFI boot data to EFI partition')
self.system_efi.sync_data()
if self.system_boot:
log.info('--> Syncing boot data at extra partition')
self.system_boot.sync_data(
self._get_exclude_list_for_boot_data_sync()
)
log.info('--> Syncing root filesystem data')
if self.root_filesystem_is_overlay:
squashed_root_file = NamedTemporaryFile()
squashed_root = FileSystemSquashFs(
device_provider=None, root_dir=self.root_dir
)
squashed_root.create_on_file(
filename=squashed_root_file.name,
exclude=self._get_exclude_list_for_root_data_sync(device_map)
)
Command.run(
[
'dd',
'if=%s' % squashed_root_file.name,
'of=%s' % device_map['readonly'].get_device()
]
)
else:
self.system.sync_data(
self._get_exclude_list_for_root_data_sync(device_map)
)
# install boot loader
self._install_bootloader(device_map)
# set root filesystem properties
self._setup_property_root_is_readonly_snapshot()
# prepare for install media if requested
if self.install_media:
log.info('Saving boot image instance to file')
self.boot_image.dump(
self.target_dir + '/boot_image.pickledump'
)
self.result.verify_image_size(
self.runtime_config.get_max_size_constraint(),
self.diskname
)
# store image file name in result
self.result.add(
key='disk_image',
filename=self.diskname,
use_for_bundle=True if not self.image_format else False,
compress=True,
shasum=True
)
# create image root metadata
self.result.add(
key='image_packages',
filename=self.system_setup.export_package_list(
self.target_dir
),
use_for_bundle=True,
compress=False,
shasum=False
)
self.result.add(
key='image_verified',
filename=self.system_setup.export_package_verification(
self.target_dir
),
use_for_bundle=True,
compress=False,
shasum=False
)
return self.result
def _build_and_map_disk_partitions(self): # noqa: C901
self.disk.wipe()
if self.firmware.legacy_bios_mode():
log.info('--> creating EFI CSM(legacy bios) partition')
self.disk.create_efi_csm_partition(
self.firmware.get_legacy_bios_partition_size()
)
if self.firmware.efi_mode():
log.info('--> creating EFI partition')
self.disk.create_efi_partition(
self.firmware.get_efi_partition_size()
)
if self.firmware.ofw_mode():
log.info('--> creating PReP partition')
self.disk.create_prep_partition(
self.firmware.get_prep_partition_size()
)
if self.disk_setup.need_boot_partition():
log.info('--> creating boot partition')
self.disk.create_boot_partition(
self.disk_setup.boot_partition_size()
)
if self.spare_part_mbsize:
log.info('--> creating spare partition')
self.disk.create_spare_partition(
self.spare_part_mbsize
)
if self.root_filesystem_is_overlay:
log.info('--> creating readonly root partition')
squashed_root_file = NamedTemporaryFile()
squashed_root = FileSystemSquashFs(
device_provider=None, root_dir=self.root_dir
)
squashed_root.create_on_file(
filename=squashed_root_file.name,
exclude=[Defaults.get_shared_cache_location()]
)
squashed_rootfs_mbsize = os.path.getsize(
squashed_root_file.name
) / 1048576
self.disk.create_root_readonly_partition(
int(squashed_rootfs_mbsize + 50)
)
if self.volume_manager_name and self.volume_manager_name == 'lvm':
log.info('--> creating LVM root partition')
self.disk.create_root_lvm_partition('all_free')
elif self.mdraid:
log.info('--> creating mdraid root partition')
self.disk.create_root_raid_partition('all_free')
else:
log.info('--> creating root partition')
self.disk.create_root_partition('all_free')
if self.firmware.bios_mode():
log.info('--> setting active flag to primary boot partition')
self.disk.activate_boot_partition()
if self.firmware.ofw_mode():
log.info('--> setting active flag to primary PReP partition')
self.disk.activate_boot_partition()
if self.firmware.efi_mode():
if self.force_mbr:
log.info('--> converting partition table to MBR')
self.disk.create_mbr()
elif self.hybrid_mbr:
log.info('--> converting partition table to hybrid GPT/MBR')
self.disk.create_hybrid_mbr()
self.disk.map_partitions()
return self.disk.get_device()
def create_install_iso(self) -> None:
"""
Create an install ISO from the disk_image as hybrid ISO
bootable via legacy BIOS, EFI and as disk from Stick
Image types which triggers this builder are:
* installiso="true|false"
* installstick="true|false"
"""
self.media_dir = mkdtemp(
prefix='kiwi_install_media.', dir=self.target_dir
)
# unpack cdroot user files to media dir
self.setup.import_cdroot_files(self.media_dir)
# custom iso metadata
self.custom_iso_args = {
'meta_data': {
'volume_id': self.iso_volume_id,
'mbr_id': self.mbrid.get_id(),
'efi_mode': self.firmware.efi_mode(),
'ofw_mode': self.firmware.ofw_mode()
}
}
# the system image transfer is checked against a checksum
log.info('Creating disk image checksum')
self.squashed_contents = mkdtemp(
prefix='kiwi_install_squashfs.', dir=self.target_dir
)
checksum = Checksum(self.diskname)
checksum.md5(self.squashed_contents + '/' + self.md5name)
# the system image name is stored in a config file
self._write_install_image_info_to_iso_image()
if self.initrd_system == 'kiwi':
self._write_install_image_info_to_boot_image()
# the system image is stored as squashfs embedded file
log.info('Creating squashfs embedded disk image')
Command.run(
[
'cp', '-l', self.diskname,
self.squashed_contents + '/' + self.squashed_diskname
]
)
squashed_image_file = ''.join(
[
self.target_dir, '/', self.squashed_diskname, '.squashfs'
]
)
squashed_image = FileSystemSquashFs(
device_provider=DeviceProvider(),
root_dir=self.squashed_contents,
custom_args={
'compression':
self.xml_state.build_type.get_squashfscompression()
}
)
squashed_image.create_on_file(squashed_image_file)
Command.run(
['mv', squashed_image_file, self.media_dir]
)
log.info(
'Setting up install image bootloader configuration'
)
if self.firmware.efi_mode():
# setup bootloader config to boot the ISO via EFI
# This also embedds an MBR and the respective BIOS modules
# for compat boot. The complete bootloader setup will be
# based on grub
bootloader_config = BootLoaderConfig.new(
'grub2', self.xml_state, root_dir=self.root_dir,
boot_dir=self.media_dir, custom_args={
'grub_directory_name':
Defaults.get_grub_boot_directory_name(self.root_dir)
}
)
bootloader_config.setup_install_boot_images(
mbrid=self.mbrid,
lookup_path=self.boot_image_task.boot_root_directory
)
else:
# setup bootloader config to boot the ISO via isolinux.
# This allows for booting on x86 platforms in BIOS mode
# only.
bootloader_config = BootLoaderConfig.new(
'isolinux', self.xml_state, root_dir=self.root_dir,
boot_dir=self.media_dir
)
IsoToolsBase.setup_media_loader_directory(
self.boot_image_task.boot_root_directory, self.media_dir,
bootloader_config.get_boot_theme()
)
bootloader_config.write_meta_data()
bootloader_config.setup_install_image_config(
mbrid=self.mbrid
)
bootloader_config.write()
# create initrd for install image
log.info('Creating install image boot image')
self._create_iso_install_kernel_and_initrd()
# the system image initrd is stored to allow kexec
self._copy_system_image_initrd_to_iso_image()
# create iso filesystem from media_dir
log.info('Creating ISO filesystem')
iso_image = FileSystemIsoFs(
device_provider=DeviceProvider(), root_dir=self.media_dir,
custom_args=self.custom_iso_args
)
iso_image.create_on_file(self.isoname)
self.boot_image_task.cleanup()
def create_install_iso(self):
"""
Create an install ISO from the disk_image as hybrid ISO
bootable via legacy BIOS, EFI and as disk from Stick
Image types which triggers this builder are:
* installiso="true|false"
* installstick="true|false"
"""
self.media_dir = mkdtemp(
prefix='kiwi_install_media.', dir=self.target_dir
)
# custom iso metadata
self.custom_iso_args = {
'create_options': [
'-V', Defaults.get_install_volume_id(),
'-A', self.mbrid.get_id()
]
}
# the system image transfer is checked against a checksum
log.info('Creating disk image checksum')
self.squashed_contents = mkdtemp(
prefix='kiwi_install_squashfs.', dir=self.target_dir
)
checksum = Checksum(self.diskname)
checksum.md5(self.squashed_contents + '/' + self.md5name)
# the system image name is stored in a config file
self._write_install_image_info_to_iso_image()
if self.initrd_system == 'kiwi':
self._write_install_image_info_to_boot_image()
# the system image is stored as squashfs embedded file
log.info('Creating squashfs embedded disk image')
Command.run(
[
'cp', '-l', self.diskname,
self.squashed_contents + '/' + self.squashed_diskname
]
)
squashed_image_file = ''.join(
[
self.target_dir, '/', self.squashed_diskname, '.squashfs'
]
)
squashed_image = FileSystemSquashFs(
device_provider=None, root_dir=self.squashed_contents
)
squashed_image.create_on_file(squashed_image_file)
Command.run(
['mv', squashed_image_file, self.media_dir]
)
# setup bootloader config to boot the ISO via isolinux
log.info('Setting up install image bootloader configuration')
bootloader_config_isolinux = BootLoaderConfig(
'isolinux', self.xml_state, self.media_dir
)
bootloader_config_isolinux.setup_install_boot_images(
mbrid=None,
lookup_path=self.boot_image_task.boot_root_directory
)
bootloader_config_isolinux.setup_install_image_config(
mbrid=None
)
bootloader_config_isolinux.write()
# setup bootloader config to boot the ISO via EFI
bootloader_config_grub = BootLoaderConfig(
'grub2', self.xml_state, self.media_dir, {
'grub_directory_name':
Defaults.get_grub_boot_directory_name(self.root_dir)
}
)
bootloader_config_grub.setup_install_boot_images(
mbrid=self.mbrid, lookup_path=self.root_dir
)
bootloader_config_grub.setup_install_image_config(
mbrid=self.mbrid
)
bootloader_config_grub.write()
# create initrd for install image
log.info('Creating install image boot image')
self._create_iso_install_kernel_and_initrd()
# the system image initrd is stored to allow kexec
self._copy_system_image_initrd_to_iso_image()
# create iso filesystem from media_dir
log.info('Creating ISO filesystem')
iso_image = FileSystemIsoFs(
device_provider=None,
root_dir=self.media_dir,
custom_args=self.custom_iso_args
)
iso_header_offset = iso_image.create_on_file(self.isoname)
# make it hybrid
Iso.create_hybrid(
iso_header_offset, self.mbrid, self.isoname,
self.firmware.efi_mode()
)
def create_install_iso(self):
"""
Create an install ISO from the disk_image as hybrid ISO
bootable via legacy BIOS, EFI and as disk from Stick
Image types which triggers this builder are:
* installiso="true|false"
* installstick="true|false"
"""
self.media_dir = mkdtemp(
prefix='kiwi_install_media.', dir=self.target_dir
)
# custom iso metadata
self.custom_iso_args = {
'create_options': [
'-V', '"KIWI Installation System"',
'-A', self.mbrid.get_id()
]
}
# the system image transfer is checked against a checksum
log.info('Creating disk image checksum')
self.squashed_contents = mkdtemp(
prefix='kiwi_install_squashfs.', dir=self.target_dir
)
checksum = Checksum(self.diskname)
checksum.md5(self.squashed_contents + '/' + self.md5name)
# the kiwi initrd code triggers the install by trigger files
self._create_iso_install_trigger_files()
# the system image is stored as squashfs embedded file
log.info('Creating squashfs embedded disk image')
Command.run(
[
'cp', '-l', self.diskname,
self.squashed_contents + '/' + self.squashed_diskname
]
)
squashed_image_file = ''.join(
[
self.target_dir, '/', self.squashed_diskname, '.squashfs'
]
)
squashed_image = FileSystemSquashFs(
device_provider=None, root_dir=self.squashed_contents
)
squashed_image.create_on_file(squashed_image_file)
Command.run(
['mv', squashed_image_file, self.media_dir]
)
# setup bootloader config to boot the ISO via isolinux
log.info('Setting up install image bootloader configuration')
bootloader_config_isolinux = BootLoaderConfig(
'isolinux', self.xml_state, self.media_dir
)
bootloader_config_isolinux.setup_install_boot_images(
mbrid=None,
lookup_path=self.boot_image_task.boot_root_directory
)
bootloader_config_isolinux.setup_install_image_config(
mbrid=None
)
bootloader_config_isolinux.write()
# setup bootloader config to boot the ISO via EFI
bootloader_config_grub = BootLoaderConfig(
'grub2', self.xml_state, self.media_dir, {
'grub_directory_name':
Defaults.get_grub_boot_directory_name(self.root_dir)
}
)
bootloader_config_grub.setup_install_boot_images(
mbrid=self.mbrid,
lookup_path=self.boot_image_task.boot_root_directory
)
bootloader_config_grub.setup_install_image_config(
mbrid=self.mbrid
)
bootloader_config_grub.write()
# create initrd for install image
log.info('Creating install image boot image')
self._create_iso_install_kernel_and_initrd()
# create iso filesystem from media_dir
log.info('Creating ISO filesystem')
iso_image = FileSystemIsoFs(
device_provider=None,
root_dir=self.media_dir,
custom_args=self.custom_iso_args
)
iso_header_offset = iso_image.create_on_file(self.isoname)
# make it hybrid
Iso.create_hybrid(
iso_header_offset, self.mbrid, self.isoname
)
def create_disk(self):
"""
Build a bootable raw disk image
"""
if self.install_media and self.build_type_name != 'oem':
raise KiwiInstallMediaError(
'Install media requires oem type setup, got %s' %
self.build_type_name)
if self.root_filesystem_is_overlay and self.volume_manager_name:
raise KiwiVolumeManagerSetupError(
'Volume management together with root overlay is not supported'
)
# setup recovery archive, cleanup and create archive if requested
self.system_setup.create_recovery_archive()
# prepare boot(initrd) root system
log.info('Preparing boot system')
self.boot_image.prepare()
# precalculate needed disk size
disksize_mbytes = self.disk_setup.get_disksize_mbytes()
# create the disk
log.info('Creating raw disk image %s', self.diskname)
loop_provider = LoopDevice(self.diskname, disksize_mbytes,
self.blocksize)
loop_provider.create()
self.disk = Disk(self.firmware.get_partition_table_type(),
loop_provider)
# create the bootloader instance
self.bootloader_config = BootLoaderConfig(
self.bootloader, self.xml_state, self.root_dir, {
'targetbase':
loop_provider.get_device(),
'grub_directory_name':
Defaults.get_grub_boot_directory_name(self.root_dir)
})
# create disk partitions and instance device map
device_map = self._build_and_map_disk_partitions()
# create raid on current root device if requested
if self.mdraid:
self.raid_root = RaidDevice(device_map['root'])
self.raid_root.create_degraded_raid(raid_level=self.mdraid)
device_map['root'] = self.raid_root.get_device()
# create luks on current root device if requested
if self.luks:
self.luks_root = LuksDevice(device_map['root'])
self.luks_root.create_crypto_luks(passphrase=self.luks,
os=self.luks_os)
device_map['root'] = self.luks_root.get_device()
# create filesystems on boot partition(s) if any
self._build_boot_filesystems(device_map)
# create volumes and filesystems for root system
if self.volume_manager_name:
volume_manager_custom_parameters = {
'fs_mount_options':
self.custom_root_mount_args,
'root_label':
self.disk_setup.get_root_label(),
'root_is_snapshot':
self.xml_state.build_type.get_btrfs_root_is_snapshot(),
'root_is_readonly_snapshot':
self.xml_state.build_type.get_btrfs_root_is_readonly_snapshot(
),
'image_type':
self.xml_state.get_build_type_name()
}
volume_manager = VolumeManager(self.volume_manager_name,
device_map['root'],
self.root_dir + '/', self.volumes,
volume_manager_custom_parameters)
volume_manager.setup(self.volume_group_name)
volume_manager.create_volumes(self.requested_filesystem)
volume_manager.mount_volumes()
self.generic_fstab_entries += volume_manager.get_fstab(
self.persistency_type, self.requested_filesystem)
self.system = volume_manager
device_map['root'] = volume_manager.get_device()['root']
else:
log.info('Creating root(%s) filesystem on %s',
self.requested_filesystem,
device_map['root'].get_device())
filesystem_custom_parameters = {
'mount_options': self.custom_root_mount_args
}
filesystem = FileSystem(self.requested_filesystem,
device_map['root'], self.root_dir + '/',
filesystem_custom_parameters)
filesystem.create_on_device(label=self.disk_setup.get_root_label())
self.system = filesystem
# create a random image identifier
self.mbrid = SystemIdentifier()
self.mbrid.calculate_id()
# create first stage metadata to boot image
self._write_partition_id_config_to_boot_image()
self._write_recovery_metadata_to_boot_image()
self._write_raid_config_to_boot_image()
self._write_generic_fstab_to_boot_image(device_map)
self.system_setup.export_modprobe_setup(
self.boot_image.boot_root_directory)
# create first stage metadata to system image
self._write_image_identifier_to_system_image()
self._write_crypttab_to_system_image()
self._write_generic_fstab_to_system_image(device_map)
if self.root_filesystem_is_overlay:
self._create_dracut_overlay_config()
# create initrd cpio archive
self.boot_image.create_initrd(self.mbrid)
# create second stage metadata to system image
self._copy_first_boot_files_to_system_image()
self._write_bootloader_config_to_system_image(device_map)
self.mbrid.write_to_disk(self.disk.storage_provider)
# set SELinux file security contexts if context exists
self._setup_selinux_file_contexts()
# syncing system data to disk image
log.info('Syncing system to image')
if self.system_efi:
log.info('--> Syncing EFI boot data to EFI partition')
self.system_efi.sync_data()
if self.system_boot:
log.info('--> Syncing boot data at extra partition')
self.system_boot.sync_data(
self._get_exclude_list_for_boot_data_sync())
log.info('--> Syncing root filesystem data')
if self.root_filesystem_is_overlay:
squashed_root_file = NamedTemporaryFile()
squashed_root = FileSystemSquashFs(device_provider=None,
root_dir=self.root_dir)
squashed_root.create_on_file(
filename=squashed_root_file.name,
exclude=self._get_exclude_list_for_root_data_sync(device_map))
Command.run([
'dd',
'if=%s' % squashed_root_file.name,
'of=%s' % device_map['readonly'].get_device()
])
else:
self.system.sync_data(
self._get_exclude_list_for_root_data_sync(device_map))
# install boot loader
self._install_bootloader(device_map)
# set root filesystem properties
self._setup_property_root_is_readonly_snapshot()
# prepare for install media if requested
if self.install_media:
if self.initrd_system == 'dracut':
# for the installation process we need a kiwi initrd
# Therefore an extra install boot root system needs to
# be prepared if dracut was set as the initrd system
# to boot the system image
log.info('Preparing extra install boot system')
self.xml_state.build_type.set_initrd_system('kiwi')
self.initrd_system = self.xml_state.get_initrd_system()
self.boot_image = BootImageKiwi(self.xml_state,
self.target_dir,
signing_keys=self.signing_keys)
self.boot_image.prepare()
# apply disk builder metadata also needed in the install initrd
self._write_partition_id_config_to_boot_image()
self._write_recovery_metadata_to_boot_image()
self._write_raid_config_to_boot_image()
self.system_setup.export_modprobe_setup(
self.boot_image.boot_root_directory)
log.info('Saving boot image instance to file')
self.boot_image.dump(self.target_dir + '/boot_image.pickledump')
# store image file name in result
self.result.add(
key='disk_image',
filename=self.diskname,
use_for_bundle=True if not self.image_format else False,
compress=True,
shasum=True)
# create image root metadata
self.result.add(key='image_packages',
filename=self.system_setup.export_package_list(
self.target_dir),
use_for_bundle=True,
compress=False,
shasum=False)
self.result.add(key='image_verified',
filename=self.system_setup.export_package_verification(
self.target_dir),
use_for_bundle=True,
compress=False,
shasum=False)
return self.result
def create_disk(self): # noqa: C901
"""
Build a bootable raw disk image
:raises KiwiInstallMediaError:
if install media is required and image type is not oem
:raises KiwiVolumeManagerSetupError:
root overlay at the same time volumes are defined is not supported
:return: result
:rtype: instance of :class:`Result`
"""
if self.install_media and self.build_type_name != 'oem':
raise KiwiInstallMediaError(
'Install media requires oem type setup, got %s' %
self.build_type_name)
if self.root_filesystem_is_overlay and self.volume_manager_name:
raise KiwiVolumeManagerSetupError(
'Volume management together with root overlay is not supported'
)
# setup recovery archive, cleanup and create archive if requested
self.system_setup.create_recovery_archive()
# prepare boot(initrd) root system
log.info('Preparing boot system')
self.boot_image.prepare()
# precalculate needed disk size
disksize_mbytes = self.disk_setup.get_disksize_mbytes()
# create the disk
log.info('Creating raw disk image %s', self.diskname)
loop_provider = LoopDevice(self.diskname, disksize_mbytes,
self.blocksize)
loop_provider.create()
self.disk = Disk(self.firmware.get_partition_table_type(),
loop_provider, self.xml_state.get_disk_start_sector())
# create the bootloader instance
self.bootloader_config = BootLoaderConfig(
self.bootloader,
self.xml_state,
root_dir=self.root_dir,
boot_dir=self.root_dir,
custom_args={
'targetbase':
loop_provider.get_device(),
'grub_directory_name':
Defaults.get_grub_boot_directory_name(self.root_dir),
'boot_is_crypto':
self.boot_is_crypto
})
# create disk partitions and instance device map
device_map = self._build_and_map_disk_partitions(disksize_mbytes)
# create raid on current root device if requested
if self.mdraid:
self.raid_root = RaidDevice(device_map['root'])
self.raid_root.create_degraded_raid(raid_level=self.mdraid)
device_map['root'] = self.raid_root.get_device()
self.disk.public_partition_id_map['kiwi_RaidPart'] = \
self.disk.public_partition_id_map['kiwi_RootPart']
self.disk.public_partition_id_map['kiwi_RaidDev'] = \
device_map['root'].get_device()
# create luks on current root device if requested
if self.luks:
self.luks_root = LuksDevice(device_map['root'])
self.luks_boot_keyname = '/.root.keyfile'
self.luks_boot_keyfile = ''.join(
[self.root_dir, self.luks_boot_keyname])
self.luks_root.create_crypto_luks(passphrase=self.luks,
os=self.luks_os,
keyfile=self.luks_boot_keyfile
if self.boot_is_crypto else None)
if self.boot_is_crypto:
self.luks_boot_keyfile_setup = ''.join(
[self.root_dir, '/etc/dracut.conf.d/99-luks-boot.conf'])
self.boot_image.write_system_config_file(
config={'install_items': [self.luks_boot_keyname]},
config_file=self.luks_boot_keyfile_setup)
self.boot_image.include_file(
os.sep + os.path.basename(self.luks_boot_keyfile))
device_map['luks_root'] = device_map['root']
device_map['root'] = self.luks_root.get_device()
# create spare filesystem on spare partition if present
self._build_spare_filesystem(device_map)
# create filesystems on boot partition(s) if any
self._build_boot_filesystems(device_map)
# create volumes and filesystems for root system
if self.volume_manager_name:
volume_manager_custom_parameters = {
'fs_mount_options':
self.custom_root_mount_args,
'fs_create_options':
self.custom_root_creation_args,
'root_label':
self.disk_setup.get_root_label(),
'root_is_snapshot':
self.xml_state.build_type.get_btrfs_root_is_snapshot(),
'root_is_readonly_snapshot':
self.xml_state.build_type.get_btrfs_root_is_readonly_snapshot(
),
'quota_groups':
self.xml_state.build_type.get_btrfs_quota_groups(),
'image_type':
self.xml_state.get_build_type_name()
}
volume_manager = VolumeManager(self.volume_manager_name,
device_map['root'],
self.root_dir + '/', self.volumes,
volume_manager_custom_parameters)
volume_manager.setup(self.volume_group_name)
volume_manager.create_volumes(self.requested_filesystem)
volume_manager.mount_volumes()
self.generic_fstab_entries += volume_manager.get_fstab(
self.persistency_type, self.requested_filesystem)
self.system = volume_manager
device_map['root'] = volume_manager.get_device()['root']
else:
log.info('Creating root(%s) filesystem on %s',
self.requested_filesystem,
device_map['root'].get_device())
filesystem_custom_parameters = {
'mount_options': self.custom_root_mount_args,
'create_options': self.custom_root_creation_args
}
filesystem = FileSystem(self.requested_filesystem,
device_map['root'], self.root_dir + '/',
filesystem_custom_parameters)
filesystem.create_on_device(label=self.disk_setup.get_root_label())
self.system = filesystem
# create a random image identifier
self.mbrid = SystemIdentifier()
self.mbrid.calculate_id()
# create first stage metadata to boot image
self._write_partition_id_config_to_boot_image()
self._write_recovery_metadata_to_boot_image()
self._write_raid_config_to_boot_image()
self._write_generic_fstab_to_boot_image(device_map)
self.system_setup.export_modprobe_setup(
self.boot_image.boot_root_directory)
# create first stage metadata to system image
self._write_image_identifier_to_system_image()
self._write_crypttab_to_system_image()
self._write_generic_fstab_to_system_image(device_map)
if self.initrd_system == 'dracut':
if self.root_filesystem_is_multipath is False:
self.boot_image.omit_module('multipath')
if self.root_filesystem_is_overlay:
self.boot_image.include_module('kiwi-overlay')
self.boot_image.write_system_config_file(
config={'modules': ['kiwi-overlay']})
if self.build_type_name == 'oem':
self.boot_image.include_module('kiwi-repart')
# create initrd cpio archive
self.boot_image.create_initrd(self.mbrid)
# create second stage metadata to system image
self._copy_first_boot_files_to_system_image()
self._write_bootloader_meta_data_to_system_image(device_map)
self.mbrid.write_to_disk(self.disk.storage_provider)
# set SELinux file security contexts if context exists
self._setup_selinux_file_contexts()
# syncing system data to disk image
log.info('Syncing system to image')
if self.system_spare:
self.system_spare.sync_data()
if self.system_efi:
log.info('--> Syncing EFI boot data to EFI partition')
self.system_efi.sync_data()
if self.system_boot:
log.info('--> Syncing boot data at extra partition')
self.system_boot.sync_data(
self._get_exclude_list_for_boot_data_sync())
log.info('--> Syncing root filesystem data')
if self.root_filesystem_is_overlay:
squashed_root_file = NamedTemporaryFile()
squashed_root = FileSystemSquashFs(device_provider=None,
root_dir=self.root_dir)
squashed_root.create_on_file(
filename=squashed_root_file.name,
exclude=self._get_exclude_list_for_root_data_sync(device_map))
Command.run([
'dd',
'if=%s' % squashed_root_file.name,
'of=%s' % device_map['readonly'].get_device()
])
else:
self.system.sync_data(
self._get_exclude_list_for_root_data_sync(device_map))
# install boot loader
self._install_bootloader(device_map)
# set root filesystem properties
self._setup_property_root_is_readonly_snapshot()
# prepare for install media if requested
if self.install_media:
log.info('Saving boot image instance to file')
self.boot_image.dump(self.target_dir + '/boot_image.pickledump')
self.result.verify_image_size(
self.runtime_config.get_max_size_constraint(), self.diskname)
# store image file name in result
self.result.add(
key='disk_image',
filename=self.diskname,
use_for_bundle=True if not self.image_format else False,
compress=self.runtime_config.get_bundle_compression(default=True),
shasum=True)
# create image root metadata
self.result.add(key='image_packages',
filename=self.system_setup.export_package_list(
self.target_dir),
use_for_bundle=True,
compress=False,
shasum=False)
self.result.add(key='image_verified',
filename=self.system_setup.export_package_verification(
self.target_dir),
use_for_bundle=True,
compress=False,
shasum=False)
return self.result
def _build_and_map_disk_partitions(self, disk: Disk,
disksize_mbytes: float) -> Dict:
disk.wipe()
disksize_used_mbytes = 0
if self.firmware.legacy_bios_mode():
log.info('--> creating EFI CSM(legacy bios) partition')
partition_mbsize = self.firmware.get_legacy_bios_partition_size()
disk.create_efi_csm_partition(partition_mbsize)
disksize_used_mbytes += partition_mbsize
if self.firmware.efi_mode():
log.info('--> creating EFI partition')
partition_mbsize = self.firmware.get_efi_partition_size()
disk.create_efi_partition(partition_mbsize)
disksize_used_mbytes += partition_mbsize
if self.firmware.ofw_mode():
log.info('--> creating PReP partition')
partition_mbsize = self.firmware.get_prep_partition_size()
disk.create_prep_partition(partition_mbsize)
disksize_used_mbytes += partition_mbsize
if self.disk_setup.need_boot_partition():
log.info('--> creating boot partition')
partition_mbsize = self.disk_setup.boot_partition_size()
disk.create_boot_partition(partition_mbsize)
disksize_used_mbytes += partition_mbsize
if self.swap_mbytes:
if not self.volume_manager_name or self.volume_manager_name != 'lvm':
log.info('--> creating SWAP partition')
disk.create_swap_partition(f'{self.swap_mbytes}')
disksize_used_mbytes += self.swap_mbytes
if self.custom_partitions:
log.info('--> creating custom partition(s): {0}'.format(
sorted(self.custom_partitions.keys())))
disk.create_custom_partitions(self.custom_partitions)
if self.spare_part_mbsize and not self.spare_part_is_last:
log.info('--> creating spare partition')
disk.create_spare_partition(f'{self.spare_part_mbsize}')
if self.root_filesystem_is_overlay:
log.info('--> creating readonly root partition')
squashed_root_file = Temporary().new_file()
squashed_root = FileSystemSquashFs(
device_provider=DeviceProvider(),
root_dir=self.root_dir,
custom_args={
'compression':
self.xml_state.build_type.get_squashfscompression()
})
squashed_root.create_on_file(
filename=squashed_root_file.name,
exclude=[Defaults.get_shared_cache_location()])
squashed_rootfs_mbsize = int(
os.path.getsize(squashed_root_file.name) /
1048576) + Defaults.get_min_partition_mbytes()
disk.create_root_readonly_partition(squashed_rootfs_mbsize)
disksize_used_mbytes += squashed_rootfs_mbsize
if self.spare_part_mbsize and self.spare_part_is_last:
rootfs_mbsize = disksize_mbytes - disksize_used_mbytes - \
self.spare_part_mbsize - Defaults.get_min_partition_mbytes()
else:
rootfs_mbsize = 'all_free'
if self.volume_manager_name and self.volume_manager_name == 'lvm':
log.info('--> creating LVM root partition')
disk.create_root_lvm_partition(rootfs_mbsize)
elif self.mdraid:
log.info('--> creating mdraid root partition')
disk.create_root_raid_partition(rootfs_mbsize)
else:
log.info('--> creating root partition')
disk.create_root_partition(rootfs_mbsize)
if self.spare_part_mbsize and self.spare_part_is_last:
log.info('--> creating spare partition')
disk.create_spare_partition('all_free')
if self.firmware.bios_mode():
log.info('--> setting active flag to primary boot partition')
disk.activate_boot_partition()
if self.firmware.ofw_mode():
log.info('--> setting active flag to primary PReP partition')
disk.activate_boot_partition()
if self.firmware.efi_mode():
if self.force_mbr:
log.info('--> converting partition table to MBR')
disk.create_mbr()
elif self.hybrid_mbr:
log.info('--> converting partition table to hybrid GPT/MBR')
disk.create_hybrid_mbr()
disk.map_partitions()
return disk.get_device()
def _build_and_map_disk_partitions(self, disksize_mbytes): # noqa: C901
self.disk.wipe()
disksize_used_mbytes = 0
if self.firmware.legacy_bios_mode():
log.info('--> creating EFI CSM(legacy bios) partition')
partition_mbsize = self.firmware.get_legacy_bios_partition_size()
self.disk.create_efi_csm_partition(partition_mbsize)
disksize_used_mbytes += partition_mbsize
if self.firmware.efi_mode():
log.info('--> creating EFI partition')
partition_mbsize = self.firmware.get_efi_partition_size()
self.disk.create_efi_partition(partition_mbsize)
disksize_used_mbytes += partition_mbsize
if self.firmware.ofw_mode():
log.info('--> creating PReP partition')
partition_mbsize = self.firmware.get_prep_partition_size()
self.disk.create_prep_partition(partition_mbsize)
disksize_used_mbytes += partition_mbsize
if self.disk_setup.need_boot_partition():
log.info('--> creating boot partition')
partition_mbsize = self.disk_setup.boot_partition_size()
self.disk.create_boot_partition(partition_mbsize)
disksize_used_mbytes += partition_mbsize
if self.spare_part_mbsize and not self.spare_part_is_last:
log.info('--> creating spare partition')
self.disk.create_spare_partition(self.spare_part_mbsize)
if self.root_filesystem_is_overlay:
log.info('--> creating readonly root partition')
squashed_root_file = NamedTemporaryFile()
squashed_root = FileSystemSquashFs(device_provider=None,
root_dir=self.root_dir)
squashed_root.create_on_file(
filename=squashed_root_file.name,
exclude=[Defaults.get_shared_cache_location()])
squashed_rootfs_mbsize = int(
os.path.getsize(squashed_root_file.name) /
1048576) + Defaults.get_min_partition_mbytes()
self.disk.create_root_readonly_partition(squashed_rootfs_mbsize)
disksize_used_mbytes += squashed_rootfs_mbsize
if self.spare_part_mbsize and self.spare_part_is_last:
rootfs_mbsize = disksize_mbytes - disksize_used_mbytes - \
self.spare_part_mbsize - Defaults.get_min_partition_mbytes()
else:
rootfs_mbsize = 'all_free'
if self.volume_manager_name and self.volume_manager_name == 'lvm':
log.info('--> creating LVM root partition')
self.disk.create_root_lvm_partition(rootfs_mbsize)
elif self.mdraid:
log.info('--> creating mdraid root partition')
self.disk.create_root_raid_partition(rootfs_mbsize)
else:
log.info('--> creating root partition')
self.disk.create_root_partition(rootfs_mbsize)
if self.spare_part_mbsize and self.spare_part_is_last:
log.info('--> creating spare partition')
self.disk.create_spare_partition('all_free')
if self.firmware.bios_mode():
log.info('--> setting active flag to primary boot partition')
self.disk.activate_boot_partition()
if self.firmware.ofw_mode():
log.info('--> setting active flag to primary PReP partition')
self.disk.activate_boot_partition()
if self.firmware.efi_mode():
if self.force_mbr:
log.info('--> converting partition table to MBR')
self.disk.create_mbr()
elif self.hybrid_mbr:
log.info('--> converting partition table to hybrid GPT/MBR')
self.disk.create_hybrid_mbr()
self.disk.map_partitions()
return self.disk.get_device()
def setup(self, mock_exists):
mock_exists.return_value = True
self.squashfs = FileSystemSquashFs(mock.Mock(), 'root_dir')