def check_minimal_required_preferences(self):
"""
Kiwi requires some of the elements of the `preferences` element
to be present at least in one of the preferences section. This
runtime check validates <version> and <packagemanager> are
provided.
"""
message_missing_package_manager = dedent('''\n
No package manager is defined in any of the <preferences>
sections. Please add
<packagemanager>desired_package_manager<packagemanager/>
inside the <preferences> section.
''')
message_missing_version = dedent('''\n
No version is defined in any of the <preferences>
sections. Please add
<version>image_version<version/>
inside the <preferences> section.
''')
if not self.xml_state.get_package_manager():
raise KiwiRuntimeError(message_missing_package_manager)
if not self.xml_state.get_image_version():
raise KiwiRuntimeError(message_missing_version)
def check_appx_naming_conventions_valid(self) -> None:
"""
When building wsl images there are some naming conventions that
must be fulfilled to run the container on Microsoft Windows
"""
launcher_pattern = r'[^\\]+(\.[Ee][Xx][Ee])$'
message_container_launcher_invalid = dedent('''\n
Invalid WSL launcher name: {0}
WSL launcher name must match the pattern: {1}
''')
id_pattern = r'^[a-zA-Z0-9]+$'
message_container_id_invalid = dedent('''\n
Invalid WSL container application id: {0}
WSL container id must match the pattern: {1}
''')
build_type = self.xml_state.get_build_type_name()
container_config = self.xml_state.get_container_config()
container_history = container_config.get('history') or {}
if build_type == 'appx' and container_config:
launcher = container_history.get('launcher')
if launcher and not re.match(launcher_pattern, launcher):
raise KiwiRuntimeError(
message_container_launcher_invalid.format(
launcher, launcher_pattern
)
)
application_id = container_history.get('application_id')
if application_id and not re.match(id_pattern, application_id):
raise KiwiRuntimeError(
message_container_id_invalid.format(
application_id, id_pattern
)
)
def check_container_tool_chain_installed(self) -> None:
"""
When creating container images the specific tools are used in order
to import and export OCI or Docker compatible images. This check
searches for those tools to be installed in the build system and
fails if it can't find them
"""
message_tool_not_found = dedent('''\n
Required tool {name} not found in caller environment
Creation of OCI or Docker images requires the tools {name} and
skopeo to be installed on the build system. For SUSE based systems
you can find the tools at:
http://download.opensuse.org/repositories/Virtualization:/containers
''')
message_version_unsupported = dedent('''\n
{name} tool found with unknown version
''')
message_unknown_tool = dedent('''\n
Unknown tool: {0}.
Please configure KIWI with an appropriate value (umoci or buildah).
Consider this runtime configuration file syntax (/etc/kiwi.yml):
oci:
- archive_tool: umoci | buildah
''')
expected_version = (0, 1, 0)
if self.xml_state.get_build_type_name() in ['docker', 'oci']:
runtime_config = RuntimeConfig()
tool_name = runtime_config.get_oci_archive_tool()
if tool_name == 'buildah':
oci_tools = ['buildah', 'skopeo']
elif tool_name == 'umoci':
oci_tools = ['umoci', 'skopeo']
else:
raise KiwiRuntimeError(message_unknown_tool.format(tool_name))
for tool in oci_tools:
if not Path.which(filename=tool, access_mode=os.X_OK):
raise KiwiRuntimeError(
message_tool_not_found.format(name=tool)
)
elif not CommandCapabilities.check_version(
tool, expected_version, raise_on_error=False
):
raise KiwiRuntimeError(
message_version_unsupported.format(name=tool)
)
self._check_multitag_support()
def check_boot_description_exists(self) -> None:
"""
If a kiwi initrd is used, a lookup to the specified boot
description is done and fails early if it does not exist
"""
message_no_boot_reference = dedent('''\n
Boot description missing for '{0}' type
The selected '{1}' initrd_system requires a boot description
reference. Please update your type setup as follows
<type image="{0}" boot="{0}boot/..."/>
A collection of custom boot descriptions can be found
in the kiwi-boot-descriptions package
''')
message_boot_description_not_found = dedent('''\n
Boot description '{0}' not found
The selected boot description could not be found on
the build host. A collection of custom boot descriptions
can be found in the kiwi-boot-descriptions package
''')
image_types_supporting_custom_boot_description = ['oem', 'pxe']
build_type = self.xml_state.get_build_type_name()
initrd_system = self.xml_state.get_initrd_system()
if initrd_system == 'kiwi' and \
build_type in image_types_supporting_custom_boot_description:
boot_image_reference = self.xml_state.build_type.get_boot()
if not boot_image_reference:
raise KiwiRuntimeError(
message_no_boot_reference.format(build_type, initrd_system)
)
if not boot_image_reference[0] == os.sep:
boot_image_reference = os.sep.join(
[
Defaults.get_boot_image_description_path(),
boot_image_reference
]
)
if not os.path.exists(boot_image_reference):
raise KiwiRuntimeError(
message_boot_description_not_found.format(
boot_image_reference
)
)
def check_dracut_module_for_disk_oem_in_package_list(self) -> None:
"""
OEM images if configured to use dracut as initrd system
requires the KIWI provided dracut-kiwi-oem-repart module
to be installed at the time dracut is called. Thus this
runtime check examines if the required package is part of
the package list in the image description.
"""
message = dedent('''\n
Required dracut module package missing in package list
The package '{0}' is required for the selected
oem image type. Please add the following in your
<packages type="image"> section to your system XML
description:
<package name="{0}"/>
''')
required_dracut_package = 'dracut-kiwi-oem-repart'
initrd_system = self.xml_state.get_initrd_system()
disk_resize_requested = self.xml_state.get_oemconfig_oem_resize()
build_type = self.xml_state.get_build_type_name()
if build_type == 'oem' and initrd_system == 'dracut' and \
disk_resize_requested:
package_names = \
self.xml_state.get_bootstrap_packages() + \
self.xml_state.get_system_packages()
if required_dracut_package not in package_names:
raise KiwiRuntimeError(
message.format(required_dracut_package)
)
def check_dracut_module_for_oem_install_in_package_list(self) -> None:
"""
OEM images if configured to use dracut as initrd system
and configured with one of the installiso, installstick
or installpxe attributes requires the KIWI provided
dracut-kiwi-oem-dump module to be installed at the time
dracut is called. Thus this runtime check examines if the
required package is part of the package list in the
image description.
"""
message = dedent('''\n
Required dracut module package missing in package list
The package '{0}' is required to build an installation
image for the selected oem image type. Please add the
following in your <packages type="image"> section to
your system XML description:
<package name="{0}"/>
''')
required_dracut_package = 'dracut-kiwi-oem-dump'
initrd_system = self.xml_state.get_initrd_system()
build_type = self.xml_state.get_build_type_name()
if build_type == 'oem' and initrd_system == 'dracut':
install_iso = self.xml_state.build_type.get_installiso()
install_stick = self.xml_state.build_type.get_installstick()
install_pxe = self.xml_state.build_type.get_installpxe()
if install_iso or install_stick or install_pxe:
package_names = \
self.xml_state.get_bootstrap_packages() + \
self.xml_state.get_system_packages()
if required_dracut_package not in package_names:
raise KiwiRuntimeError(
message.format(required_dracut_package)
)
def check_volume_setup_defines_reserved_labels(self) -> None:
message = dedent('''\n
Reserved label name used in LVM volume setup
The label setup for volume {0} uses the reserved label {1}.
Reserved labels used by KIWI internally are {2}. Please
choose another label name for this volume.
''')
reserved_labels = [
self.xml_state.build_type.get_rootfs_label() or 'ROOT',
'SWAP', 'SPARE'
]
volume_management = self.xml_state.get_volume_management()
if volume_management == 'lvm':
for volume in self.xml_state.get_volumes():
# A swap volume is created implicitly if oem-swap is
# requested. This volume detected via realpath set to
# swap is skipped from the reserved label check as it
# intentionally uses the reserved label named SWAP
if volume.realpath != 'swap':
if volume.label and volume.label in reserved_labels:
raise KiwiRuntimeError(
message.format(
volume.name, volume.label, reserved_labels
)
)
def check_swap_name_used_with_lvm(self) -> None:
"""
The optional oem-swapname is only effective if used together
with the LVM volume manager. A name for the swap space can
only be set if it is created as a LVM volume. In any other
case the name does not apply to the system
"""
message = dedent('''\n
Specified swap space name: {0} will not be used
The specified oem-swapname is used without the LVM volume
manager. This means the swap space will be created as simple
partition for which no name assignment can take place.
The name specified in oem-swapname is used to give the
LVM swap volume a name. Outside of LVM the setting is
meaningless and should be removed.
Please delete the following setting from your image
description:
<oem-swapname>{0}</oem-swapname>
''')
volume_management = self.xml_state.get_volume_management()
if volume_management != 'lvm':
oemconfig = self.xml_state.get_build_type_oemconfig_section()
if oemconfig and oemconfig.get_oem_swapname():
raise KiwiRuntimeError(
message.format(oemconfig.get_oem_swapname()[0])
)
def check_initrd_selection_required(self) -> None:
"""
If the boot attribute is used without selecting kiwi
as the initrd_system, the setting of the boot attribute
will not have any effect. We assume that configurations
which explicitly specify the boot attribute wants to use
the custom kiwi initrd system and not dracut.
"""
message_kiwi_initrd_system_not_selected = dedent('''\n
Missing initrd_system selection for boot attribute
The selected boot="'{0}'" boot description indicates
the custom kiwi initrd system should be used instead
of dracut. If this is correct please explicitly request
the kiwi initrd system as follows:
<type initrd_system="kiwi"/>
If this is not want you want and dracut should be used
as initrd system, please delete the boot attribute
as it is obsolete in this case.
''')
initrd_system = self.xml_state.get_initrd_system()
boot_image_reference = self.xml_state.build_type.get_boot()
if initrd_system != 'kiwi' and boot_image_reference:
raise KiwiRuntimeError(
message_kiwi_initrd_system_not_selected.format(
boot_image_reference
)
)
def check_volume_label_used_with_lvm(self) -> None:
"""
The optional volume label in a systemdisk setup is only
effective if the LVM, logical volume manager system is
used. In any other case where the filesystem itself offers
volume management capabilities there are no extra filesystem
labels which can be applied per volume
"""
message = dedent('''\n
Custom volume label setup used without LVM
The optional volume label in a systemdisk setup is only
effective if the LVM, logical volume manager system is
used. Your setup uses the {0} filesystem which itself
offers volume management capabilities. Extra filesystem
labels cannot be applied in this case.
If you want to force LVM over the {0} volume management
system you can do so by specifying the following in
your KIWI XML description:
<systemdisk ... preferlvm="true">
<volume .../>
</systemdisk>
''')
volume_management = self.xml_state.get_volume_management()
if volume_management != 'lvm':
for volume in self.xml_state.get_volumes():
if volume.label and volume.label != 'SWAP':
raise KiwiRuntimeError(
message.format(volume_management)
)
def check_image_include_repos_publicly_resolvable(self) -> None:
"""
Verify that all repos marked with the imageinclude attribute
can be resolved into a http based web URL
"""
message = dedent('''\n
The use of imageinclude="true" in the repository definition
for the Repository: {0}
requires the repository to by publicly available. The source
locator of the repository however indicates it is private to
your local system. Therefore it can't be included into the
system image repository configuration. Please define a publicly
available repository in your image XML description.
''')
repository_sections = self.xml_state.get_repository_sections()
for xml_repo in repository_sections:
repo_marked_for_image_include = xml_repo.get_imageinclude()
if repo_marked_for_image_include:
repo_source = xml_repo.get_source().get_path()
repo_type = xml_repo.get_type()
uri = Uri(repo_source, repo_type)
if not uri.is_public():
raise KiwiRuntimeError(
message.format(repo_source)
)
def check_efi_mode_for_disk_overlay_correctly_setup(self) -> None:
"""
Disk images configured to use a root filesystem overlay
only supports the standard EFI mode and not secure boot.
That's because the shim setup performs changes to the
root filesystem which can not be applied during the
bootloader setup at build time because at that point
the root filesystem is a read-only squashfs source.
"""
message = dedent('''\n
Secure Boot not supported with overlay disk image
Disk images configured to use a root filesystem overlay
only supports the standard EFI mode and not secure boot.
That's because the shim setup performs changes to the
root filesystem which can not be applied during the
bootloader setup at build time because at that point
the root filesystem is a read-only squashfs source
Thus please change the firmware attribute in the <type>
section of the system XML description as follows:
<type ... firmware="efi"/>
''')
overlayroot = self.xml_state.build_type.get_overlayroot()
firmware = self.xml_state.build_type.get_firmware()
if overlayroot and firmware == 'uefi':
raise KiwiRuntimeError(message)
def check_syslinux_installed_if_isolinux_is_used(self) -> None:
"""
ISO images that are configured to use isolinux
requires the host to provide a set of syslinux
binaries.
"""
message = dedent('''\n
Required syslinux module(s) not found
The ISO image build for this image setup uses isolinux
and therefore requires the syslinux modules to be
available on the build host. Please make sure your
build host has the syslinux package installed.
''')
firmware = FirmWare(self.xml_state)
if Defaults.is_x86_arch(
Defaults.get_platform_name()
) and not firmware.efi_mode():
image_builds_iso = False
build_type = self.xml_state.get_build_type_name()
if build_type == 'iso':
image_builds_iso = True
elif build_type == 'oem':
install_iso = self.xml_state.build_type.get_installiso()
install_stick = self.xml_state.build_type.get_installstick()
if install_iso or install_stick:
image_builds_iso = True
if image_builds_iso:
syslinux_check_file = Path.which(
'isohdpfx.bin', Defaults.get_syslinux_search_paths()
)
if not syslinux_check_file:
raise KiwiRuntimeError(message)
def check_include_references_unresolvable(self) -> None:
"""
Raise for still included <include> statements as not resolvable.
The KIWI XSLT processing replaces the specified include
directive(s) with the given file reference(s). If this action
did not happen for example on nested includes, it can happen
that they stay in the document as sort of waste.
"""
message = dedent('''\n
One ore more <include> statements are unresolvable
The following include references could not be resolved.
Please verify the specified location(s) and/or delete
the broken include directive(s) from the description.
Please also note, nested includes from other include
files are not supported:
{0}
''')
include_files = \
self.xml_state.get_include_section_reference_file_names()
if include_files:
raise KiwiRuntimeError(
message.format(json.dumps(include_files, indent=4))
)
def check_architecture_supports_iso_firmware_setup(self) -> None:
"""
For creating ISO images a different bootloader setup is
performed depending on the configured firmware. If the
firmware is set to bios, isolinux is used and that limits
the architecture to x86 only. In any other case the appliance
configured bootloader is used. This check examines if the
host architecture is supported with the configured firmware
on request of an ISO image.
"""
message = dedent('''\n
Unsupported firmware setup: {0} on {1} architecture
The selected firmware limits the creation of images to
the x86 platform. For the detected build host architecture
and the request to build a live or install ISO media
the EFI firmware must be used:
<type ... firmware="efi"/>
''')
arch = Defaults.get_platform_name()
build_type = self.xml_state.get_build_type_name()
firmware = self.xml_state.build_type.get_firmware() or \
Defaults.get_default_firmware(arch)
if firmware == 'bios' and not Defaults.is_x86_arch(arch):
iso_build_requested = False
if build_type == 'iso':
iso_build_requested = True
elif build_type == 'oem':
install_iso = self.xml_state.build_type.get_installiso()
install_stick = self.xml_state.build_type.get_installstick()
if install_iso or install_stick:
iso_build_requested = True
if iso_build_requested:
raise KiwiRuntimeError(message.format(firmware, arch))
def check_dracut_module_for_disk_overlay_in_package_list(self) -> None:
"""
Disk images configured to use a root filesystem overlay
requires the KIWI provided kiwi-overlay dracut module to
be installed at the time dracut is called. Thus this
runtime check examines if the required package is part of
the package list in the image description.
"""
message = dedent('''\n
Required dracut module package missing in package list
The package '{0}' is required for the selected
overlayroot activated image type. Please add the
following in your <packages type="image"> section to
your system XML description:
<package name="{0}"/>
''')
required_dracut_package = 'dracut-kiwi-overlay'
if self.xml_state.build_type.get_overlayroot():
package_names = \
self.xml_state.get_bootstrap_packages() + \
self.xml_state.get_system_packages()
if required_dracut_package not in package_names:
raise KiwiRuntimeError(
message.format(required_dracut_package)
)
def check_dracut_module_for_live_iso_in_package_list(self) -> None:
"""
Live ISO images uses a dracut initrd to boot and requires
the KIWI provided kiwi-live dracut module to be installed
at the time dracut is called. Thus this runtime check
examines if the required package is part of the package
list in the image description.
"""
message = dedent('''\n
Required dracut module package missing in package list
The package '{0}' is required for the selected
live iso image type. Please add the following in your
<packages type="image"> section to your system XML
description:
<package name="{0}"/>
''')
required_dracut_package = 'dracut-kiwi-live'
type_name = self.xml_state.get_build_type_name()
type_flag = self.xml_state.build_type.get_flags()
if type_name == 'iso' and type_flag != 'dmsquash':
package_names = \
self.xml_state.get_bootstrap_packages() + \
self.xml_state.get_system_packages()
if required_dracut_package not in package_names:
raise KiwiRuntimeError(
message.format(required_dracut_package)
)
def check_repositories_configured(self) -> None:
"""
Verify that there are repositories configured
"""
if not self.xml_state.get_repository_sections():
raise KiwiRuntimeError(
'No repositories configured'
)
def _check_multitag_support(self) -> None:
message = dedent('''\n
Using additionaltags attribute requires skopeo tool to be
capable to handle it, it must include the '--additional-tag'
option for copy subcommand (check it running 'skopeo copy
--help').\n
It is known to be present since v0.1.30
''')
if 'additional_names' in self.xml_state.get_container_config():
if not CommandCapabilities.has_option_in_help(
'skopeo', '--additional-tag', ['copy', '--help'],
raise_on_error=False
):
raise KiwiRuntimeError(message)
def check_xen_uniquely_setup_as_server_or_guest(self) -> None:
"""
If the image is classified to be used as Xen image, it can
be either a Xen Server(dom0) or a Xen guest. The image
configuration is checked if the information uniquely identifies
the image as such
"""
xen_message = dedent('''\n
Inconsistent Xen setup found:
The use of the 'xen_server' or 'xen_loader' attributes indicates
the target system for this image is Xen. However the image
specifies both attributes at the same time which classifies
the image to be both, a Xen Server(dom0) and a Xen guest at
the same time, which is not supported.
Please cleanup your image description. Setup only one
of 'xen_server' or 'xen_loader'.
''')
ec2_message = dedent('''\n
Inconsistent Amazon EC2 setup found:
The firmware setup indicates the target system for this image
is Amazon EC2, which uses a Xen based virtualisation technology.
Therefore the image must be classified as a Xen guest and can
not be a Xen server as indicated by the 'xen_server' attribute
Please cleanup your image description. Delete the 'xen_server'
attribute for images used with Amazon EC2.
''')
if self.xml_state.is_xen_server() and self.xml_state.is_xen_guest():
firmware = self.xml_state.build_type.get_firmware()
ec2_firmware_names = Defaults.get_ec2_capable_firmware_names()
if firmware and firmware in ec2_firmware_names:
raise KiwiRuntimeError(ec2_message)
else:
raise KiwiRuntimeError(xen_message)
def check_image_version_provided(self) -> None:
"""
Kiwi requires a <version> element to be specified as part
of at least one <preferences> section.
"""
message_missing_version = dedent('''\n
No version is defined in any of the <preferences>
sections. Please add
<version>image_version<version/>
inside the <preferences> section.
''')
if not self.xml_state.get_image_version():
raise KiwiRuntimeError(message_missing_version)
def check_mediacheck_installed(self) -> None:
"""
If the image description enables the mediacheck attribute
the required tools to run this check must be installed
on the image build host
"""
message_tool_not_found = dedent('''\n
Required tool {name} not found in caller environment
The attribute 'mediacheck' is set to 'true' which requires
the above tool to be installed on the build system
''')
if self.xml_state.build_type.get_mediacheck() is True:
tool = 'tagmedia'
if not Path.which(filename=tool, access_mode=os.X_OK):
raise KiwiRuntimeError(
message_tool_not_found.format(name=tool))
def check_volume_setup_defines_reserved_labels(self):
message = dedent('''\n
Reserved label name used in LVM volume setup
The label setup for volume {0} uses the reserved label {1}.
Reserved labels used by KIWI internally are {2}. Please
choose another label name for this volume.
''')
reserved_labels = [
self.xml_state.build_type.get_rootfs_label() or 'ROOT', 'SWAP',
'SPARE'
]
volume_management = self.xml_state.get_volume_management()
if volume_management == 'lvm':
for volume in self.xml_state.get_volumes():
if volume.name != 'LVSwap':
if volume.label and volume.label in reserved_labels:
raise KiwiRuntimeError(
message.format(volume.name, volume.label,
reserved_labels))
def check_image_type_unique(self) -> None:
"""
Verify that the selected image type is unique within
the range of the configured types and profiles.
"""
message = dedent('''\n
Conflicting image type setup detected
The selected image type '{0}' in the {1} profile
selection is not unique. There are the followng type
settings which overrides each other:
{2}
To solve this conflict please move the image type
setup into its own profile and select them using
the --profile option at call time.
''')
image_type_sections = []
type_dict: Dict[str, List[Any]] = {}
for preferences in self.xml_state.get_preferences_sections():
image_type_sections += preferences.get_type()
for image_type in image_type_sections:
type_name = image_type.get_image()
if type_dict.get(type_name):
type_dict[type_name].append(image_type)
else:
type_dict[type_name] = [image_type]
for type_name, type_list in list(type_dict.items()):
if len(type_list) > 1:
type_export = StringIO()
for image_type in type_list:
type_export.write(os.linesep)
image_type.export(type_export, 0)
raise KiwiRuntimeError(
message.format(
type_name, self.xml_state.profiles or ['Default'],
type_export.getvalue()
)
)
def check_partuuid_persistency_type_used_with_mbr(self) -> None:
"""
The devicepersistency setting by-partuuid can only be
used in combination with a partition table type that
supports UUIDs. In any other case Linux creates artificial
values for PTUUID and PARTUUID from the disk signature
which can change without touching the actual partition
table. We consider this unsafe and only allow the use
of by-partuuid in combination with partition tables that
actually supports it properly.
"""
message = dedent('''\n
devicepersistency={0!r} used with non UUID capable partition table
PTUUID and PARTUUID exists in the GUID (GPT) partition table.
According to the firmware setting: {1!r}, the selected partition
table type is: {2!r}. This table type does not natively support
UUIDs. In such a case Linux creates artificial values for PTUUID
and PARTUUID from the disk signature which can change without
touching the actual partition table. This is considered unsafe
and KIWI only allows the use of by-partuuid in combination with
partition tables that actually supports UUIDs properly.
Please make sure to use one of the following firmware settings
which leads to an image using an UUID capable partition table
and therefore supporting consistent by-partuuid device names:
<type ... firmware="efi|uefi">
''')
persistency_type = self.xml_state.build_type.get_devicepersistency()
if persistency_type and persistency_type == 'by-partuuid':
supported_table_types = ['gpt']
firmware = FirmWare(self.xml_state)
table_type = firmware.get_partition_table_type()
if table_type not in supported_table_types:
raise KiwiRuntimeError(
message.format(
persistency_type, firmware.firmware, table_type
)
)
def check_volume_setup_has_no_root_definition(self) -> None:
"""
The root volume in a systemdisk setup is handled in a special
way. It is not allowed to setup a custom name or mountpoint for
the root volume. Therefore the size of the root volume can be
setup via the @root volume name. This check looks up the volume
setup and searches if there is a configuration for the '/'
mountpoint which would cause the image build to fail
"""
message = dedent('''\n
Volume setup for "/" found. The size of the root volume
must be specified via the @root volume name like the
following example shows:
<volume name="@root" size="42G"/>
A custom name or mountpoint for the root volume is not
allowed.
''')
for volume in self.xml_state.get_volumes():
if volume.mountpoint == '/':
raise KiwiRuntimeError(message)
def check_luksformat_options_valid(self) -> None:
"""
Options set via the luksformat element are passed along
to the cryptsetup tool. Only options that are known to
the tool should be allowed. Thus this runtime check looks
up the provided option names if they exist in the cryptsetup
version used on the build host
"""
message = dedent('''\n
Option {0!r} not found in cryptsetup
The Option {0!r} could not be found in the help output
of the cryptsetup tool.
''')
luksformat = self.xml_state.build_type.get_luksformat()
if luksformat:
for option in luksformat[0].get_option():
argument = option.get_name()
if not CommandCapabilities.has_option_in_help(
'cryptsetup', argument, ['--help'],
raise_on_error=False
):
raise KiwiRuntimeError(message.format(argument))
def check_target_directory_not_in_shared_cache(target_dir: str) -> None:
"""
The target directory must be outside of the kiwi shared cache
directory in order to avoid busy mounts because kiwi bind mounts
the cache directory into the image root tree to access host
caching information
:param string target_dir: path name
"""
message = dedent('''\n
Target directory %s conflicts with kiwi's shared cache
directory %s. This is going to create a busy loop mount.
Please choose another target directory.
''')
shared_cache_location = Defaults.get_shared_cache_location()
target_dir_stack = os.path.abspath(
os.path.normpath(target_dir)).replace(os.sep + os.sep,
os.sep).split(os.sep)
if target_dir_stack[1:4] == shared_cache_location.split(os.sep):
raise KiwiRuntimeError(message %
(target_dir, shared_cache_location))
def check_volume_setup_defines_multiple_fullsize_volumes(self) -> None:
"""
The volume size specification 'all' makes this volume to
take the rest space available on the system. It's only
allowed to specify one all size volume
"""
message = dedent('''\n
Multiple all size volumes found but only one is allowed
The volume size specification 'all' makes this volume to
take the rest space available on the system. It's only
allowed to specify one all size volume
''')
systemdisk_section = self.xml_state.get_build_type_system_disk_section()
if systemdisk_section:
all_size_volume_count = 0
volumes = systemdisk_section.get_volume() or []
for volume in volumes:
size = volume.get_size() or volume.get_freespace()
if size and 'all' in size:
all_size_volume_count += 1
if all_size_volume_count > 1:
raise KiwiRuntimeError(message)
def check_dracut_module_versions_compatible_to_kiwi(
self, root_dir: str
) -> None:
"""
KIWI images which makes use of kiwi dracut modules
has to use module versions compatible with the version
of this KIWI builder code base. This is important to avoid
inconsistencies between the way how kiwi includes its own
dracut modules and former version of those dracut modules
which could be no longer compatible with the builder.
Therefore this runtime check maintains a min_version constraint
for which we know this KIWI builder to be compatible with.
"""
message = dedent('''\n
Incompatible dracut-kiwi module(s) found
The image was build with KIWI version={0}. The system
root tree has the following dracut-kiwi-* module packages
installed which are too old to work with this version of KIWI.
Please make sure to use dracut-kiwi-* module packages
which are >= than the versions listed below.
{1}
''')
kiwi_dracut_modules = {
'90kiwi-dump': dracut_module_type(
'dracut-kiwi-oem-dump', '9.20.1'
),
'90kiwi-live': dracut_module_type(
'dracut-kiwi-live', '9.20.1'
),
'90kiwi-overlay': dracut_module_type(
'dracut-kiwi-overlay', '9.20.1'
),
'90kiwi-repart': dracut_module_type(
'dracut-kiwi-oem-repart', '9.20.1'
),
'99kiwi-dump-reboot': dracut_module_type(
'dracut-kiwi-oem-dump', '9.20.1'
),
'99kiwi-lib': dracut_module_type(
'dracut-kiwi-lib', '9.20.1'
)
}
dracut_module_dir = os.sep.join(
[root_dir, '/usr/lib/dracut/modules.d']
)
if not os.path.isdir(dracut_module_dir):
# no dracut module dir present
return
incompatible_modules = {}
for module in os.listdir(dracut_module_dir):
module_meta = kiwi_dracut_modules.get(module)
if module_meta:
module_version = self._get_dracut_module_version_from_pdb(
self.xml_state.get_package_manager(),
module_meta.package, root_dir
)
if module_version:
module_version_nr = tuple(
int(it) for it in module_version.split('.')
)
module_min_version_nr = tuple(
int(it) for it in module_meta.min_version.split('.')
)
if module_version_nr < module_min_version_nr:
incompatible_modules[
module_meta.package
] = 'got:{0}, need:>={1}'.format(
module_version, module_meta.min_version
)
if incompatible_modules:
raise KiwiRuntimeError(
message.format(__version__, incompatible_modules)
)