kiwi.runtime_checker API documentation

RuntimeChecker(xml_state: kiwi.xml_state.XMLState) View Source

60    def __init__(self, xml_state: XMLState) -> None:
61        """
62        The schema of an image description covers structure and syntax of
63        the provided data. The RuntimeChecker provides methods to perform
64        further semantic checks which allows to recognize potential build
65        or boot problems early.
66
67        :param object xml_state: Instance of XMLState
68        """
69        self.xml_state = xml_state

The schema of an image description covers structure and syntax of the provided data. The RuntimeChecker provides methods to perform further semantic checks which allows to recognize potential build or boot problems early.

Parameters

object xml_state: Instance of XMLState

xml_state

def check_repositories_configured(self) -> None: View Source

71    def check_repositories_configured(self) -> None:
72        """
73        Verify that there are repositories configured
74        """
75        if not self.xml_state.get_repository_sections():
76            raise KiwiRuntimeError(
77                'No repositories configured'
78            )

Verify that there are repositories configured

@staticmethod

def check_target_dir_on_unsupported_filesystem(target_dir: str) -> None: View Source

 80    @staticmethod
 81    def check_target_dir_on_unsupported_filesystem(target_dir: str) -> None:
 82        """
 83        Raise if the given target dir does not reside on a
 84        filesystem that supports all important features like
 85        extended permissions(fscaps), ACLs or xattrs.
 86        """
 87        message = dedent('''\n
 88            Target root/image directory is lacking filesystem features
 89
 90            The filesystem {0} in the target path {1}
 91            does not support important features like extended permissions,
 92            ACLs or xattrs. The image build may fail or the resulting
 93            image misbehave.
 94        ''')
 95        target_dir = Path.first_exists(target_dir)
 96        stat = Command.run(['stat', '-f', '-c', '%T', target_dir])
 97        if stat:
 98            target_fs = stat.output.strip()
 99            supported_target_filesystem = (
100                'btrfs',
101                'ext2',
102                'ext2/ext3',
103                'ext3',
104                'ext4',
105                'overlayfs',
106                'tmpfs',
107                'xfs',
108            )
109            if target_fs not in supported_target_filesystem:
110                raise KiwiRuntimeError(message.format(target_fs, target_dir))

Raise if the given target dir does not reside on a filesystem that supports all important features like extended permissions(fscaps), ACLs or xattrs.

def check_include_references_unresolvable(self) -> None: View Source

112    def check_include_references_unresolvable(self) -> None:
113        """
114        Raise for still included <include> statements as not resolvable.
115        The KIWI XSLT processing replaces the specified include
116        directive(s) with the given file reference(s). If this action
117        did not happen for example on nested includes, it can happen
118        that they stay in the document as sort of waste.
119        """
120        message = dedent('''\n
121            One ore more <include> statements are unresolvable
122
123            The following include references could not be resolved.
124            Please verify the specified location(s) and/or delete
125            the broken include directive(s) from the description.
126            Please also note, nested includes from other include
127            files are not supported:
128
129            {0}
130        ''')
131        include_files = \
132            self.xml_state.get_include_section_reference_file_names()
133        if include_files:
134            raise KiwiRuntimeError(
135                message.format(json.dumps(include_files, indent=4))
136            )

Raise for still included 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.

def check_image_include_repos_publicly_resolvable(self) -> None: View Source

138    def check_image_include_repos_publicly_resolvable(self) -> None:
139        """
140        Verify that all repos marked with the imageinclude attribute
141        can be resolved into a http based web URL
142        """
143        message = dedent('''\n
144            The use of imageinclude="true" in the repository definition
145            for the Repository: {0}
146            requires the repository to by publicly available. The source
147            locator of the repository however indicates it is private to
148            your local system. Therefore it can't be included into the
149            system image repository configuration. Please define a publicly
150            available repository in your image XML description.
151        ''')
152
153        repository_sections = self.xml_state.get_repository_sections()
154        for xml_repo in repository_sections:
155            repo_marked_for_image_include = xml_repo.get_imageinclude()
156
157            if repo_marked_for_image_include:
158                repo_source = xml_repo.get_source().get_path()
159                repo_type = xml_repo.get_type()
160                uri = Uri(repo_source, repo_type)
161                if not uri.is_public():
162                    raise KiwiRuntimeError(
163                        message.format(repo_source)
164                    )

Verify that all repos marked with the imageinclude attribute can be resolved into a http based web URL

@staticmethod

def check_target_directory_not_in_shared_cache(target_dir: str) -> None: View Source

166    @staticmethod
167    def check_target_directory_not_in_shared_cache(target_dir: str) -> None:
168        """
169        The target directory must be outside of the kiwi shared cache
170        directory in order to avoid busy mounts because kiwi bind mounts
171        the cache directory into the image root tree to access host
172        caching information
173
174        :param string target_dir: path name
175        """
176        message = dedent('''\n
177            Target directory %s conflicts with kiwi's shared cache
178            directory %s. This is going to create a busy loop mount.
179            Please choose another target directory.
180        ''')
181
182        shared_cache_location = Defaults.get_shared_cache_location()
183
184        target_dir_stack = os.path.abspath(
185            os.path.normpath(target_dir)
186        ).replace(os.sep + os.sep, os.sep).split(os.sep)
187        if target_dir_stack[1:4] == shared_cache_location.split(os.sep):
188            raise KiwiRuntimeError(
189                message % (target_dir, shared_cache_location)
190            )

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

Parameters

string target_dir: path name

def check_volume_label_used_with_lvm(self) -> None: View Source

192    def check_volume_label_used_with_lvm(self) -> None:
193        """
194        The optional volume label in a systemdisk setup is only
195        effective if the LVM, logical volume manager system is
196        used. In any other case where the filesystem itself offers
197        volume management capabilities there are no extra filesystem
198        labels which can be applied per volume
199        """
200        message = dedent('''\n
201            Custom volume label setup used without LVM
202
203            The optional volume label in a systemdisk setup is only
204            effective if the LVM, logical volume manager system is
205            used. Your setup uses the {0} filesystem which itself
206            offers volume management capabilities. Extra filesystem
207            labels cannot be applied in this case.
208
209            If you want to force LVM over the {0} volume management
210            system you can do so by specifying the following in
211            your KIWI XML description:
212
213            <systemdisk ... preferlvm="true">
214                <volume .../>
215            </systemdisk>
216        ''')
217        volume_management = self.xml_state.get_volume_management()
218        if volume_management != 'lvm':
219            for volume in self.xml_state.get_volumes():
220                if volume.label and volume.label != 'SWAP':
221                    raise KiwiRuntimeError(
222                        message.format(volume_management)
223                    )

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

def check_partuuid_persistency_type_used_with_mbr(self) -> None: View Source

225    def check_partuuid_persistency_type_used_with_mbr(self) -> None:
226        """
227        The devicepersistency setting by-partuuid can only be
228        used in combination with a partition table type that
229        supports UUIDs. In any other case Linux creates artificial
230        values for PTUUID and PARTUUID from the disk signature
231        which can change without touching the actual partition
232        table. We consider this unsafe and only allow the use
233        of by-partuuid in combination with partition tables that
234        actually supports it properly.
235        """
236        message = dedent('''\n
237            devicepersistency={0!r} used with non UUID capable partition table
238
239            PTUUID and PARTUUID exists in the GUID (GPT) partition table.
240            According to the firmware setting: {1!r}, the selected partition
241            table type is: {2!r}. This table type does not natively support
242            UUIDs. In such a case Linux creates artificial values for PTUUID
243            and PARTUUID from the disk signature which can change without
244            touching the actual partition table. This is considered unsafe
245            and KIWI only allows the use of by-partuuid in combination with
246            partition tables that actually supports UUIDs properly.
247
248            Please make sure to use one of the following firmware settings
249            which leads to an image using an UUID capable partition table
250            and therefore supporting consistent by-partuuid device names:
251
252            <type ... firmware="efi|uefi">
253        ''')
254        persistency_type = self.xml_state.build_type.get_devicepersistency()
255        if persistency_type and persistency_type == 'by-partuuid':
256            supported_table_types = ['gpt']
257            firmware = FirmWare(self.xml_state)
258            table_type = firmware.get_partition_table_type()
259            if table_type not in supported_table_types:
260                raise KiwiRuntimeError(
261                    message.format(
262                        persistency_type, firmware.firmware, table_type
263                    )
264                )

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.

def check_swap_name_used_with_lvm(self) -> None: View Source

266    def check_swap_name_used_with_lvm(self) -> None:
267        """
268        The optional oem-swapname is only effective if used together
269        with the LVM volume manager. A name for the swap space can
270        only be set if it is created as a LVM volume. In any other
271        case the name does not apply to the system
272        """
273        message = dedent('''\n
274             Specified swap space name: {0} will not be used
275
276             The specified oem-swapname is used without the LVM volume
277             manager. This means the swap space will be created as simple
278             partition for which no name assignment can take place.
279             The name specified in oem-swapname is used to give the
280             LVM swap volume a name. Outside of LVM the setting is
281             meaningless and should be removed.
282
283             Please delete the following setting from your image
284             description:
285
286             <oem-swapname>{0}</oem-swapname>
287        ''')
288        volume_management = self.xml_state.get_volume_management()
289        if volume_management != 'lvm':
290            oemconfig = self.xml_state.get_build_type_oemconfig_section()
291            if oemconfig and oemconfig.get_oem_swapname():
292                raise KiwiRuntimeError(
293                    message.format(oemconfig.get_oem_swapname()[0])
294                )

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

def check_volume_setup_defines_reserved_labels(self) -> None: View Source

296    def check_volume_setup_defines_reserved_labels(self) -> None:
297        message = dedent('''\n
298            Reserved label name used in LVM volume setup
299
300            The label setup for volume {0} uses the reserved label {1}.
301            Reserved labels used by KIWI internally are {2}. Please
302            choose another label name for this volume.
303        ''')
304        reserved_labels = [
305            self.xml_state.build_type.get_rootfs_label() or 'ROOT',
306            'SWAP', 'SPARE'
307        ]
308        volume_management = self.xml_state.get_volume_management()
309        if volume_management == 'lvm':
310            for volume in self.xml_state.get_volumes():
311                # A swap volume is created implicitly if oem-swap is
312                # requested. This volume detected via realpath set to
313                # swap is skipped from the reserved label check as it
314                # intentionally uses the reserved label named SWAP
315                if volume.realpath != 'swap':
316                    if volume.label and volume.label in reserved_labels:
317                        raise KiwiRuntimeError(
318                            message.format(
319                                volume.name, volume.label, reserved_labels
320                            )
321                        )

def check_volume_setup_defines_multiple_fullsize_volumes(self) -> None: View Source

323    def check_volume_setup_defines_multiple_fullsize_volumes(self) -> None:
324        """
325        The volume size specification 'all' makes this volume to
326        take the rest space available on the system. It's only
327        allowed to specify one all size volume
328        """
329        message = dedent('''\n
330            Multiple all size volumes found but only one is allowed
331
332            The volume size specification 'all' makes this volume to
333            take the rest space available on the system. It's only
334            allowed to specify one all size volume
335        ''')
336        systemdisk_section = self.xml_state.get_build_type_system_disk_section()
337        if systemdisk_section:
338            all_size_volume_count = 0
339            volumes = systemdisk_section.get_volume() or []
340            for volume in volumes:
341                size = volume.get_size() or volume.get_freespace()
342                if size and 'all' in size:
343                    all_size_volume_count += 1
344            if all_size_volume_count > 1:
345                raise KiwiRuntimeError(message)

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

def check_volume_setup_has_no_root_definition(self) -> None: View Source

347    def check_volume_setup_has_no_root_definition(self) -> None:
348        """
349        The root volume in a systemdisk setup is handled in a special
350        way. It is not allowed to setup a custom name or mountpoint for
351        the root volume. Therefore the size of the root volume can be
352        setup via the @root volume name. This check looks up the volume
353        setup and searches if there is a configuration for the '/'
354        mountpoint which would cause the image build to fail
355        """
356        message = dedent('''\n
357            Volume setup for "/" found. The size of the root volume
358            must be specified via the @root volume name like the
359            following example shows:
360
361            <volume name="@root" size="42G"/>
362
363            A custom name or mountpoint for the root volume is not
364            allowed.
365        ''')
366        for volume in self.xml_state.get_volumes():
367            if volume.mountpoint == '/':
368                raise KiwiRuntimeError(message)

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

def check_container_tool_chain_installed(self) -> None: View Source

370    def check_container_tool_chain_installed(self) -> None:
371        """
372        When creating container images the specific tools are used in order
373        to import and export OCI or Docker compatible images. This check
374        searches for those tools to be installed in the build system and
375        fails if it can't find them
376        """
377        message_tool_not_found = dedent('''\n
378            Required tool {name} not found in caller environment
379
380            Creation of OCI or Docker images requires the tools {name} and
381            skopeo to be installed on the build system. For SUSE based systems
382            you can find the tools at:
383
384            http://download.opensuse.org/repositories/Virtualization:/containers
385        ''')
386        message_version_unsupported = dedent('''\n
387            {name} tool found with unknown version
388        ''')
389        message_unknown_tool = dedent('''\n
390            Unknown tool: {0}.
391
392            Please configure KIWI with an appropriate value (umoci or buildah).
393            Consider this runtime configuration file syntax (/etc/kiwi.yml):
394
395            oci:
396                - archive_tool: umoci | buildah
397        ''')
398
399        expected_version = (0, 1, 0)
400
401        if self.xml_state.get_build_type_name() in ['docker', 'oci']:
402            runtime_config = RuntimeConfig()
403            tool_name = runtime_config.get_oci_archive_tool()
404            if tool_name == 'buildah':
405                oci_tools = ['buildah', 'skopeo']
406            elif tool_name == 'umoci':
407                oci_tools = ['umoci', 'skopeo']
408            else:
409                raise KiwiRuntimeError(message_unknown_tool.format(tool_name))
410            for tool in oci_tools:
411                if not Path.which(filename=tool, access_mode=os.X_OK):
412                    raise KiwiRuntimeError(
413                        message_tool_not_found.format(name=tool)
414                    )
415                elif not CommandCapabilities.check_version(
416                    tool, expected_version, raise_on_error=False
417                ):
418                    raise KiwiRuntimeError(
419                        message_version_unsupported.format(name=tool)
420                    )
421            self._check_multitag_support()

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

def check_luksformat_options_valid(self) -> None: View Source

438    def check_luksformat_options_valid(self) -> None:
439        """
440        Options set via the luksformat element are passed along
441        to the cryptsetup tool. Only options that are known to
442        the tool should be allowed. Thus this runtime check looks
443        up the provided option names if they exist in the cryptsetup
444        version used on the build host
445        """
446        message = dedent('''\n
447            Option {0!r} not found in cryptsetup
448
449            The Option {0!r} could not be found in the help output
450            of the cryptsetup tool.
451        ''')
452        luksformat = self.xml_state.build_type.get_luksformat()
453        if luksformat:
454            for option in luksformat[0].get_option():
455                argument = option.get_name()
456                if not CommandCapabilities.has_option_in_help(
457                    'cryptsetup', argument, ['--help'],
458                    raise_on_error=False
459                ):
460                    raise KiwiRuntimeError(message.format(argument))

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

def check_appx_naming_conventions_valid(self) -> None: View Source

462    def check_appx_naming_conventions_valid(self) -> None:
463        """
464        When building wsl images there are some naming conventions that
465        must be fulfilled to run the container on Microsoft Windows
466        """
467        launcher_pattern = r'[^\\]+(\.[Ee][Xx][Ee])$'
468        message_container_launcher_invalid = dedent('''\n
469            Invalid WSL launcher name: {0}
470
471            WSL launcher name must match the pattern: {1}
472        ''')
473        id_pattern = r'^[a-zA-Z0-9]+$'
474        message_container_id_invalid = dedent('''\n
475            Invalid WSL container application id: {0}
476
477            WSL container id must match the pattern: {1}
478        ''')
479        build_type = self.xml_state.get_build_type_name()
480        container_config = self.xml_state.get_container_config()
481        container_history = container_config.get('history') or {}
482        if build_type == 'appx' and container_config:
483            launcher = container_history.get('launcher')
484            if launcher and not re.match(launcher_pattern, launcher):
485                raise KiwiRuntimeError(
486                    message_container_launcher_invalid.format(
487                        launcher, launcher_pattern
488                    )
489                )
490            application_id = container_history.get('application_id')
491            if application_id and not re.match(id_pattern, application_id):
492                raise KiwiRuntimeError(
493                    message_container_id_invalid.format(
494                        application_id, id_pattern
495                    )
496                )

When building wsl images there are some naming conventions that must be fulfilled to run the container on Microsoft Windows

def check_initrd_selection_required(self) -> None: View Source

498    def check_initrd_selection_required(self) -> None:
499        """
500        If the boot attribute is used without selecting kiwi
501        as the initrd_system, the setting of the boot attribute
502        will not have any effect. We assume that configurations
503        which explicitly specify the boot attribute wants to use
504        the custom kiwi initrd system and not dracut.
505        """
506        message_kiwi_initrd_system_not_selected = dedent('''\n
507            Missing initrd_system selection for boot attribute
508
509            The selected boot="'{0}'" boot description indicates
510            the custom kiwi initrd system should be used instead
511            of dracut. If this is correct please explicitly request
512            the kiwi initrd system as follows:
513
514            <type initrd_system="kiwi"/>
515
516            If this is not want you want and dracut should be used
517            as initrd system, please delete the boot attribute
518            as it is obsolete in this case.
519        ''')
520        initrd_system = self.xml_state.get_initrd_system()
521        boot_image_reference = self.xml_state.build_type.get_boot()
522        if initrd_system != 'kiwi' and boot_image_reference:
523            raise KiwiRuntimeError(
524                message_kiwi_initrd_system_not_selected.format(
525                    boot_image_reference
526                )
527            )

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.

def check_boot_description_exists(self) -> None: View Source

529    def check_boot_description_exists(self) -> None:
530        """
531        If a kiwi initrd is used, a lookup to the specified boot
532        description is done and fails early if it does not exist
533        """
534        message_no_boot_reference = dedent('''\n
535            Boot description missing for '{0}' type
536
537            The selected '{1}' initrd_system requires a boot description
538            reference. Please update your type setup as follows
539
540            <type image="{0}" boot="{0}boot/..."/>
541
542            A collection of custom boot descriptions can be found
543            in the kiwi-boot-descriptions package
544        ''')
545        message_boot_description_not_found = dedent('''\n
546            Boot description '{0}' not found
547
548            The selected boot description could not be found on
549            the build host. A collection of custom boot descriptions
550            can be found in the kiwi-boot-descriptions package
551        ''')
552        image_types_supporting_custom_boot_description = ['oem', 'pxe']
553        build_type = self.xml_state.get_build_type_name()
554        initrd_system = self.xml_state.get_initrd_system()
555        if initrd_system == 'kiwi' and \
556           build_type in image_types_supporting_custom_boot_description:
557
558            boot_image_reference = self.xml_state.build_type.get_boot()
559            if not boot_image_reference:
560                raise KiwiRuntimeError(
561                    message_no_boot_reference.format(build_type, initrd_system)
562                )
563
564            if not boot_image_reference[0] == os.sep:
565                boot_image_reference = os.sep.join(
566                    [
567                        Defaults.get_boot_image_description_path(),
568                        boot_image_reference
569                    ]
570                )
571            if not os.path.exists(boot_image_reference):
572                raise KiwiRuntimeError(
573                    message_boot_description_not_found.format(
574                        boot_image_reference
575                    )
576                )

If a kiwi initrd is used, a lookup to the specified boot description is done and fails early if it does not exist

def check_consistent_kernel_in_boot_and_system_image(self) -> None: View Source

578    def check_consistent_kernel_in_boot_and_system_image(self) -> None:
579        """
580        If a kiwi initrd is used, the kernel used to build the kiwi
581        initrd and the kernel used in the system image must be the
582        same in order to avoid an inconsistent boot setup
583        """
584        message = dedent('''\n
585            Possible kernel mismatch between kiwi initrd and system image
586
587            The selected '{0}' boot image kernel is '{1}'. However this
588            kernel package was not explicitly listed in the package list
589            of the system image. Please fixup your system image
590            description:
591
592            1) Add <package name="{1}"/> to your system XML description
593
594            2) Inherit kernel from system description to initrd via
595               the custom kernel profile:
596
597               <type ... bootkernel="custom" .../>
598
599               <packages type="image"/>
600                   <package name="desired-kernel" bootinclude="true"/>
601               </packages>
602        ''')
603        boot_image_reference = self.xml_state.build_type.get_boot()
604        boot_kernel_package_name = None
605        if boot_image_reference:
606            if not boot_image_reference[0] == '/':
607                boot_image_reference = os.sep.join(
608                    [
609                        Defaults.get_boot_image_description_path(),
610                        boot_image_reference
611                    ]
612                )
613            boot_config_file = os.sep.join(
614                [boot_image_reference, 'config.xml']
615            )
616            if os.path.exists(boot_config_file):
617                boot_description = XMLDescription(
618                    description=boot_config_file,
619                    derived_from=self.xml_state.xml_data.description_dir
620                )
621                boot_kernel_profile = \
622                    self.xml_state.build_type.get_bootkernel()
623                if not boot_kernel_profile:
624                    boot_kernel_profile = 'std'
625                boot_xml_state = XMLState(
626                    boot_description.load(), [boot_kernel_profile]
627                )
628                kernel_package_sections = []
629                for packages_section in boot_xml_state.xml_data.get_packages():
630                    # lookup package sections matching kernel profile in kiwi
631                    # boot description. By definition this must be a packages
632                    # section with a single profile name whereas the default
633                    # profile name is 'std'. The section itself must contain
634                    # one matching kernel package name for the desired
635                    # architecture
636                    if packages_section.get_profiles() == boot_kernel_profile:
637                        for package in packages_section.get_package():
638                            kernel_package_sections.append(package)
639
640                for package in kernel_package_sections:
641                    if boot_xml_state.package_matches_host_architecture(
642                            package
643                    ):
644                        boot_kernel_package_name = package.get_name()
645
646        if boot_kernel_package_name:
647            # A kernel package name was found in the kiwi boot image
648            # description. Let's check if this kernel is also used
649            # in the system image
650            image_package_names = self.xml_state.get_system_packages()
651            if boot_kernel_package_name not in image_package_names:
652                raise KiwiRuntimeError(
653                    message.format(
654                        self.xml_state.build_type.get_boot(),
655                        boot_kernel_package_name
656                    )
657                )

If a kiwi initrd is used, the kernel used to build the kiwi initrd and the kernel used in the system image must be the same in order to avoid an inconsistent boot setup

def check_dracut_module_versions_compatible_to_kiwi(self, root_dir: str) -> None: View Source

659    def check_dracut_module_versions_compatible_to_kiwi(
660        self, root_dir: str
661    ) -> None:
662        """
663        KIWI images which makes use of kiwi dracut modules
664        has to use module versions compatible with the version
665        of this KIWI builder code base. This is important to avoid
666        inconsistencies between the way how kiwi includes its own
667        dracut modules and former version of those dracut modules
668        which could be no longer compatible with the builder.
669        Therefore this runtime check maintains a min_version constraint
670        for which we know this KIWI builder to be compatible with.
671        """
672        message = dedent('''\n
673            Incompatible dracut-kiwi module(s) found
674
675            The image was build with KIWI version={0}. The system
676            root tree has the following dracut-kiwi-* module packages
677            installed which are too old to work with this version of KIWI.
678            Please make sure to use dracut-kiwi-* module packages
679            which are >= than the versions listed below.
680
681            {1}
682        ''')
683        kiwi_dracut_modules = {
684            '55kiwi-dump': dracut_module_type(
685                'dracut-kiwi-oem-dump', '9.20.1'
686            ),
687            '55kiwi-live': dracut_module_type(
688                'dracut-kiwi-live', '9.20.1'
689            ),
690            '55kiwi-overlay': dracut_module_type(
691                'dracut-kiwi-overlay', '9.20.1'
692            ),
693            '55kiwi-repart': dracut_module_type(
694                'dracut-kiwi-oem-repart', '9.20.1'
695            ),
696            '59kiwi-dump-reboot': dracut_module_type(
697                'dracut-kiwi-oem-dump', '9.20.1'
698            ),
699            '59kiwi-lib': dracut_module_type(
700                'dracut-kiwi-lib', '9.20.1'
701            )
702        }
703        dracut_module_dir = os.sep.join(
704            [root_dir, '/usr/lib/dracut/modules.d']
705        )
706        if not os.path.isdir(dracut_module_dir):
707            # no dracut module dir present
708            return
709
710        incompatible_modules = {}
711        for module in os.listdir(dracut_module_dir):
712            module_meta = kiwi_dracut_modules.get(module)
713            if module_meta:
714                module_version = self._get_dracut_module_version_from_pdb(
715                    self.xml_state.get_package_manager(),
716                    module_meta.package, root_dir
717                )
718                if module_version:
719                    module_version_nr = tuple(
720                        int(it) for it in module_version.split('.')
721                    )
722                    module_min_version_nr = tuple(
723                        int(it) for it in module_meta.min_version.split('.')
724                    )
725                    if module_version_nr < module_min_version_nr:
726                        incompatible_modules[
727                            module_meta.package
728                        ] = 'got:{0}, need:>={1}'.format(
729                            module_version, module_meta.min_version
730                        )
731        if incompatible_modules:
732            raise KiwiRuntimeError(
733                message.format(__version__, incompatible_modules)
734            )

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.

def check_dracut_module_for_oem_install_in_package_list(self) -> None: View Source

736    def check_dracut_module_for_oem_install_in_package_list(self) -> None:
737        """
738        OEM images if configured to use dracut as initrd system
739        and configured with one of the installiso, installstick
740        or installpxe attributes requires the KIWI provided
741        dracut-kiwi-oem-dump module to be installed at the time
742        dracut is called. Thus this runtime check examines if the
743        required package is part of the package list in the
744        image description.
745        """
746        message = dedent('''\n
747            Required dracut module package missing in package list
748
749            One of the packages '{0}' is required
750            to build an installation image for the selected oem image type.
751            Depending on your distribution, add the following in the
752            <packages type="image"> section:
753
754            <package name="ONE_FROM_ABOVE"/>
755        ''')
756        meta = Defaults.get_runtime_checker_metadata()
757        required_dracut_packages = meta['package_names']['dracut_oem_dump']
758        initrd_system = self.xml_state.get_initrd_system()
759        build_type = self.xml_state.get_build_type_name()
760        if build_type == 'oem' and initrd_system == 'dracut':
761            install_iso = self.xml_state.build_type.get_installiso()
762            install_stick = self.xml_state.build_type.get_installstick()
763            install_pxe = self.xml_state.build_type.get_installpxe()
764            if install_iso or install_stick or install_pxe:
765                package_names = \
766                    self.xml_state.get_bootstrap_packages() + \
767                    self.xml_state.get_system_packages()
768                if not RuntimeChecker._package_in_list(
769                    package_names, required_dracut_packages
770                ):
771                    raise KiwiRuntimeError(
772                        message.format(required_dracut_packages)
773                    )

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.

def check_dracut_module_for_disk_oem_in_package_list(self) -> None: View Source

775    def check_dracut_module_for_disk_oem_in_package_list(self) -> None:
776        """
777        OEM images if configured to use dracut as initrd system
778        requires the KIWI provided dracut-kiwi-oem-repart module
779        to be installed at the time dracut is called. Thus this
780        runtime check examines if the required package is part of
781        the package list in the image description.
782        """
783        message = dedent('''\n
784            Required dracut module package missing in package list
785
786            One of the packages '{0}' is required
787            for the selected oem image type. Depending on your distribution,
788            add the following in the <packages type="image"> section:
789
790            <package name="ONE_FROM_ABOVE"/>
791        ''')
792        meta = Defaults.get_runtime_checker_metadata()
793        required_dracut_packages = meta['package_names']['dracut_oem_repart']
794        initrd_system = self.xml_state.get_initrd_system()
795        disk_resize_requested = self.xml_state.get_oemconfig_oem_resize()
796        build_type = self.xml_state.get_build_type_name()
797        if build_type == 'oem' and initrd_system == 'dracut' and \
798           disk_resize_requested:
799            package_names = \
800                self.xml_state.get_bootstrap_packages() + \
801                self.xml_state.get_system_packages()
802            if not RuntimeChecker._package_in_list(
803                package_names, required_dracut_packages
804            ):
805                raise KiwiRuntimeError(
806                    message.format(required_dracut_packages)
807                )

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.

def check_dracut_module_for_live_iso_in_package_list(self) -> None: View Source

809    def check_dracut_module_for_live_iso_in_package_list(self) -> None:
810        """
811        Live ISO images uses a dracut initrd to boot and requires
812        the KIWI provided kiwi-live dracut module to be installed
813        at the time dracut is called. Thus this runtime check
814        examines if the required package is part of the package
815        list in the image description.
816        """
817        message = dedent('''\n
818            Required dracut module package missing in package list
819
820            One of the packages '{0}' is required
821            for the selected live iso image type. Depending on your distribution,
822            add the following in your <packages type="image"> section:
823
824            <package name="ONE_FROM_ABOVE"/>
825        ''')
826        meta = Defaults.get_runtime_checker_metadata()
827        required_dracut_packages = meta['package_names']['dracut_live']
828        type_name = self.xml_state.get_build_type_name()
829        type_flag = self.xml_state.build_type.get_flags()
830        if type_name == 'iso' and type_flag != 'dmsquash':
831            package_names = \
832                self.xml_state.get_bootstrap_packages() + \
833                self.xml_state.get_system_packages()
834            if not RuntimeChecker._package_in_list(
835                package_names, required_dracut_packages
836            ):
837                raise KiwiRuntimeError(
838                    message.format(required_dracut_packages)
839                )

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.

def check_dracut_module_for_disk_overlay_in_package_list(self) -> None: View Source

841    def check_dracut_module_for_disk_overlay_in_package_list(self) -> None:
842        """
843        Disk images configured to use a root filesystem overlay
844        requires the KIWI provided kiwi-overlay dracut module to
845        be installed at the time dracut is called. Thus this
846        runtime check examines if the required package is part of
847        the package list in the image description.
848        """
849        message = dedent('''\n
850            Required dracut module package missing in package list
851
852            The package '{0}' is required
853            for the selected overlayroot activated image type.
854            Depending on your distribution, add the following in your
855            <packages type="image"> section:
856
857            <package name="ONE_FROM_ABOVE"/>
858        ''')
859        initrd_system = self.xml_state.get_initrd_system()
860        meta = Defaults.get_runtime_checker_metadata()
861        required_dracut_packages = meta['package_names']['dracut_overlay']
862        if initrd_system == 'dracut' and \
863           self.xml_state.build_type.get_overlayroot():
864            package_names = \
865                self.xml_state.get_bootstrap_packages() + \
866                self.xml_state.get_system_packages()
867            if not RuntimeChecker._package_in_list(
868                package_names, required_dracut_packages
869            ):
870                raise KiwiRuntimeError(
871                    message.format(required_dracut_packages)
872                )

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.

def check_xen_uniquely_setup_as_server_or_guest(self) -> None: View Source

874    def check_xen_uniquely_setup_as_server_or_guest(self) -> None:
875        """
876        If the image is classified to be used as Xen image, it can
877        be either a Xen Server(dom0) or a Xen guest. The image
878        configuration is checked if the information uniquely identifies
879        the image as such
880        """
881        xen_message = dedent('''\n
882            Inconsistent Xen setup found:
883
884            The use of the 'xen_server' or 'xen_loader' attributes indicates
885            the target system for this image is Xen. However the image
886            specifies both attributes at the same time which classifies
887            the image to be both, a Xen Server(dom0) and a Xen guest at
888            the same time, which is not supported.
889
890            Please cleanup your image description. Setup only one
891            of 'xen_server' or 'xen_loader'.
892        ''')
893        ec2_message = dedent('''\n
894            Inconsistent Amazon EC2 setup found:
895
896            The firmware setup indicates the target system for this image
897            is Amazon EC2, which uses a Xen based virtualisation technology.
898            Therefore the image must be classified as a Xen guest and can
899            not be a Xen server as indicated by the 'xen_server' attribute
900
901            Please cleanup your image description. Delete the 'xen_server'
902            attribute for images used with Amazon EC2.
903        ''')
904        if self.xml_state.is_xen_server() and self.xml_state.is_xen_guest():
905            firmware = self.xml_state.build_type.get_firmware()
906            ec2_firmware_names = Defaults.get_ec2_capable_firmware_names()
907            if firmware and firmware in ec2_firmware_names:
908                raise KiwiRuntimeError(ec2_message)
909            else:
910                raise KiwiRuntimeError(xen_message)

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

def check_mediacheck_installed(self) -> None: View Source

912    def check_mediacheck_installed(self) -> None:
913        """
914        If the image description enables the mediacheck attribute
915        the required tools to run this check must be installed
916        on the image build host
917        """
918        message_tool_not_found = dedent('''\n
919            Required tool {name} not found in caller environment
920
921            The attribute 'mediacheck' is set to 'true' which requires
922            the above tool to be installed on the build system
923        ''')
924        if self.xml_state.build_type.get_mediacheck() is True:
925            tool = 'tagmedia'
926            media_tagger = RuntimeConfig().get_iso_media_tag_tool()
927            if media_tagger == 'checkmedia':
928                tool = 'tagmedia'
929            elif media_tagger == 'isomd5sum':
930                tool = 'implantisomd5'
931            if not Path.which(filename=tool, access_mode=os.X_OK):
932                raise KiwiRuntimeError(
933                    message_tool_not_found.format(name=tool)
934                )

If the image description enables the mediacheck attribute the required tools to run this check must be installed on the image build host

def check_image_version_provided(self) -> None: View Source

936    def check_image_version_provided(self) -> None:
937        """
938        Kiwi requires a <version> element to be specified as part
939        of at least one <preferences> section.
940        """
941        message_missing_version = dedent('''\n
942            No version is defined in any of the <preferences>
943            sections. Please add
944
945                <version>image_version<version/>
946
947            inside the <preferences> section.
948        ''')
949
950        if not self.xml_state.get_image_version():
951            raise KiwiRuntimeError(message_missing_version)

Kiwi requires a element to be specified as part of at least one section.

def check_image_type_unique(self) -> None: View Source

953    def check_image_type_unique(self) -> None:
954        """
955        Verify that the selected image type is unique within
956        the range of the configured types and profiles.
957        """
958        message = dedent('''\n
959            Conflicting image type setup detected
960
961            The selected image type '{0}' in the {1} profile
962            selection is not unique. There are the following type
963            settings which overrides each other:
964            {2}
965            To solve this conflict please move the image type
966            setup into its own profile and select them using
967            the --profile option at call time.
968        ''')
969        image_type_sections = []
970        type_dict: Dict[str, List[Any]] = {}
971        for preferences in self.xml_state.get_preferences_sections():
972            image_type_sections += preferences.get_type()
973
974        for image_type in image_type_sections:
975            type_name = image_type.get_image()
976            if type_dict.get(type_name):
977                type_dict[type_name].append(image_type)
978            else:
979                type_dict[type_name] = [image_type]
980
981        for type_name, type_list in list(type_dict.items()):
982            if len(type_list) > 1:
983                type_export = StringIO()
984                for image_type in type_list:
985                    type_export.write(os.linesep)
986                    image_type.export(type_export, 0)
987                raise KiwiRuntimeError(
988                    message.format(
989                        type_name, self.xml_state.profiles or ['Default'],
990                        type_export.getvalue()
991                    )
992                )

Verify that the selected image type is unique within the range of the configured types and profiles.

def check_efi_fat_image_has_correct_size(self) -> None: View Source

 994    def check_efi_fat_image_has_correct_size(self) -> None:
 995        """
 996        Verify that the efifatimagesize does not exceed the max
 997        El Torito load size of 65535 * 512 bytes
 998        """
 999        message = dedent('''\n
1000            El Torito max load size exceeded
1001
1002            The configured efifatimagesize of '{0}MB' exceeds
1003            the El Torito max load size of 65535 * 512 bytes (~31MB).
1004        ''')
1005        fat_image_mbsize = int(
1006            self.xml_state.build_type
1007                .get_efifatimagesize() or defaults.EFI_FAT_IMAGE_SIZE
1008        )
1009        if fat_image_mbsize > 31:
1010            raise KiwiRuntimeError(
1011                message.format(fat_image_mbsize)
1012            )

Verify that the efifatimagesize does not exceed the max El Torito load size of 65535 * 512 bytes

def check_bootloader_env_compatible_with_loader(self) -> None: View Source

1014    def check_bootloader_env_compatible_with_loader(self) -> None:
1015        """
1016        If there is an environment section as part of the bootloader
1017        section, check if the selected loader supports custom
1018        environment blobs
1019        """
1020        message = dedent('''\n
1021            Selected loader does not support custom environments
1022
1023            The selected bootloader {} does not support custom
1024            environment settings. Please drop the <environment>
1025            setting from <bootloadersettings> for this loader
1026        ''')
1027        env_supported_loaders = [
1028            'grub2',
1029            'grub2_s390x_emu',
1030            'custom'
1031        ]
1032        bootloader = self.xml_state.get_build_type_bootloader_name()
1033        variable_list = self.xml_state.\
1034            get_build_type_bootloader_environment_variables()
1035        if variable_list and bootloader not in env_supported_loaders:
1036            raise KiwiRuntimeError(
1037                message.format(bootloader)
1038            )

If there is an environment section as part of the bootloader section, check if the selected loader supports custom environment blobs