kiwi.defaults

   1# Copyright (c) 2015 SUSE Linux GmbH.  All rights reserved.
   2#
   3# This file is part of kiwi.
   4#
   5# kiwi is free software: you can redistribute it and/or modify
   6# it under the terms of the GNU General Public License as published by
   7# the Free Software Foundation, either version 3 of the License, or
   8# (at your option) any later version.
   9#
  10# kiwi is distributed in the hope that it will be useful,
  11# but WITHOUT ANY WARRANTY; without even the implied warranty of
  12# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13# GNU General Public License for more details.
  14#
  15# You should have received a copy of the GNU General Public License
  16# along with kiwi.  If not, see <http://www.gnu.org/licenses/>
  17#
  18import logging
  19import os
  20import glob
  21import importlib
  22from importlib.resources import as_file
  23from importlib.util import find_spec
  24from importlib.machinery import ModuleSpec
  25from collections import namedtuple
  26import platform
  27import yaml
  28from typing import (
  29    List, NamedTuple, Optional, Dict
  30)
  31
  32# project
  33from kiwi.path import Path
  34from kiwi.version import (
  35    __githash__,
  36    __version__
  37)
  38
  39from kiwi.exceptions import KiwiBootLoaderGrubDataError
  40
  41shim_loader_type = NamedTuple(
  42    'shim_loader_type', [
  43        ('filename', str),
  44        ('binaryname', str)
  45    ]
  46)
  47
  48grub_loader_type = NamedTuple(
  49    'grub_loader_type', [
  50        ('filename', str),
  51        ('binaryname', str),
  52        ('targetname', str)
  53    ]
  54)
  55
  56unit_type = NamedTuple(
  57    'unit_type', [
  58        ('byte', str),
  59        ('kb', str),
  60        ('mb', str),
  61        ('gb', str)
  62    ]
  63)
  64
  65
  66# Default module variables
  67DM_METADATA_FORMAT_VERSION = '1'
  68DM_METADATA_OFFSET = 4096  # 4kb
  69VERITY_DATA_BLOCKSIZE = 4096  # 4kb
  70VERITY_HASH_BLOCKSIZE = 4096  # 4kb
  71INTEGRITY_SECTOR_SIZE = 512
  72
  73INTEGRITY_ALGORITHM = 'sha256'
  74INTEGRITY_KEY_ALGORITHM = 'hmac-sha256'
  75
  76UNIT = unit_type(byte='b', kb='k', mb='m', gb='g')
  77POST_DISK_SYNC_SCRIPT = 'disk.sh'
  78PRE_DISK_SYNC_SCRIPT = 'pre_disk_sync.sh'
  79POST_BOOTSTRAP_SCRIPT = 'post_bootstrap.sh'
  80POST_PREPARE_SCRIPT = 'config.sh'
  81POST_PREPARE_OVERLAY_SCRIPT = 'config-overlay.sh'
  82POST_HOST_PREPARE_OVERLAY_SCRIPT = 'config-host-overlay.sh'
  83PRE_CREATE_SCRIPT = 'images.sh'
  84EDIT_BOOT_CONFIG_SCRIPT = 'edit_boot_config.sh'
  85EDIT_BOOT_INSTALL_SCRIPT = 'edit_boot_install.sh'
  86IMAGE_METADATA_DIR = 'image'
  87ROOT_VOLUME_NAME = 'LVRoot'
  88SHARED_CACHE_DIR = '/var/cache/kiwi'
  89MODULE_SPEC: Optional[ModuleSpec] = find_spec('kiwi')
  90RUNTIME_CHECKER_METADATA = '{}/runtime_checker_metadata.yml'.format(
  91    os.path.dirname(MODULE_SPEC.origin or 'unknown')
  92) if MODULE_SPEC else 'unknown'
  93
  94TEMP_DIR = '/var/tmp'
  95LOCAL_CONTAINERS = '/var/tmp/kiwi_containers'
  96CUSTOM_RUNTIME_CONFIG_FILE = None
  97ETC_RUNTIME_CONFIG_FILE = '/etc/kiwi.yml'
  98ETC_RUNTIME_CONFIG_DIR = '/etc/kiwi.yml.d'
  99USR_RUNTIME_CONFIG_FILE = '/usr/share/kiwi/kiwi.yml'
 100USR_RUNTIME_CONFIG_DIR = '/usr/share/kiwi/kiwi.yml.d'
 101PLATFORM_MACHINE = platform.machine()
 102EFI_FAT_IMAGE_SIZE = 20
 103
 104# optional package manager environment variables
 105PACKAGE_MANAGER_ENV_VARS = '/.kiwi.package_manager.env'
 106
 107# Distribution specific CA store and tooling
 108CA_UPDATE_MAP = {
 109    'suse': {
 110        'tool': 'update-ca-certificates',
 111        'destination_path': '/etc/pki/trust/anchors'
 112    },
 113    'redhat': {
 114        'tool': 'update-ca-trust',
 115        'destination_path': '/etc/pki/ca-trust/source/anchors/'
 116    },
 117    'debian': {
 118        'tool': 'update-ca-certificates',
 119        'destination_path': '/usr/local/share/ca-certificates/'
 120    },
 121    'archlinux': {
 122        'tool': 'update-ca-trust',
 123        'destination_path': '/etc/ca-certificates/trust-source/anchors/'
 124    }
 125}
 126
 127log = logging.getLogger('kiwi')
 128
 129
 130class Defaults:
 131    """
 132    **Implements default values**
 133
 134    Provides static methods for default values and state information
 135    """
 136
 137    def __init__(self):
 138        self.defaults = {
 139            # alignment in bytes
 140            'kiwi_align': 1048576,
 141            # start sector number
 142            'kiwi_startsector': 2048,
 143            # sectorsize in bytes
 144            'kiwi_sectorsize': 512,
 145            # inode size in bytes for inode based filesystems
 146            'kiwi_inode_size': 256,
 147            # inode ratio for inode based filesystems
 148            'kiwi_inode_ratio': 16384,
 149            # minimum inode number for inode based filesystems
 150            'kiwi_min_inodes': 20000,
 151            # kiwi git revision
 152            'kiwi_revision': __githash__
 153        }
 154        self.profile_key_list = [
 155            'kiwi_align',
 156            'kiwi_startsector',
 157            'kiwi_sectorsize',
 158            'kiwi_revision'
 159        ]
 160
 161    @staticmethod
 162    def get_luks_key_length():
 163        """
 164        Provides key length to use for random luks keys
 165        """
 166        return 256
 167
 168    @staticmethod
 169    def get_swapsize_mbytes():
 170        """
 171        Provides swapsize in MB
 172        """
 173        return 128
 174
 175    @staticmethod
 176    def get_xz_compression_options():
 177        """
 178        Provides compression options for the xz compressor
 179
 180        :return:
 181            Contains list of options
 182
 183            .. code:: python
 184
 185                ['--option=value']
 186
 187        :rtype: list
 188        """
 189        return [
 190            '--threads=0'
 191        ]
 192
 193    @staticmethod
 194    def get_platform_name():
 195        """
 196        Provides the machine architecture name as used by KIWI
 197
 198        This is the architecture name as it is returned by 'uname -m'
 199        with one exception for the 32bit x86 architecture which is
 200        handled as 'ix86' in general
 201
 202        :return: architecture name
 203
 204        :rtype: str
 205        """
 206        arch = PLATFORM_MACHINE
 207        if arch == 'i686' or arch == 'i586':
 208            arch = 'ix86'
 209        return arch
 210
 211    @staticmethod
 212    def set_platform_name(name: str):
 213        """
 214        Sets the platform architecture once
 215
 216        :param str name: an architecture name
 217        """
 218        global PLATFORM_MACHINE
 219        PLATFORM_MACHINE = name
 220
 221    @staticmethod
 222    def is_x86_arch(arch):
 223        """
 224        Checks if machine architecture is x86 based
 225
 226        Any arch that matches 32bit and 64bit x86 architecture
 227        causes the method to return True. Anything else will
 228        cause the method to return False
 229
 230        :rtype: bool
 231        """
 232        x86_arch_names = [
 233            'x86_64', 'i686', 'i586', 'ix86'
 234        ]
 235        if arch in x86_arch_names:
 236            return True
 237        return False
 238
 239    @staticmethod
 240    def is_ppc64_arch(arch):
 241        """
 242        Checks if machine architecture is ppc64 based
 243
 244        Any arch that matches little endian or big endian ppc64 architecture
 245        causes the method to return True. Anything else will
 246        cause the method to return False
 247
 248        :rtype: bool
 249        """
 250        ppc64_arch_names = [
 251            'ppc64', 'ppc64le'
 252        ]
 253        if arch in ppc64_arch_names:
 254            return True
 255        return False
 256
 257    @staticmethod
 258    def is_buildservice_worker():
 259        """
 260        Checks if build host is an open buildservice machine
 261
 262        The presence of /.buildenv on the build host indicates
 263        we are building inside of the open buildservice
 264
 265        :return: True if obs worker, else False
 266
 267        :rtype: bool
 268        """
 269        return os.path.exists(
 270            os.sep + Defaults.get_buildservice_env_name()
 271        )
 272
 273    @staticmethod
 274    def get_buildservice_env_name():
 275        """
 276        Provides the base name of the environment file in a
 277        buildservice worker
 278
 279        :return: file basename
 280
 281        :rtype: str
 282        """
 283        return '.buildenv'
 284
 285    @staticmethod
 286    def get_obs_download_server_url():
 287        """
 288        Provides the default download server url hosting the public open
 289        buildservice repositories
 290
 291        :return: url path
 292
 293        :rtype: str
 294        """
 295        return 'http://download.opensuse.org/repositories'
 296
 297    @staticmethod
 298    def get_obs_api_server_url():
 299        """
 300        Provides the default API server url to access the
 301        public open buildservice API
 302
 303        :return: url path
 304
 305        :rtype: str
 306        """
 307        return 'https://api.opensuse.org'
 308
 309    @staticmethod
 310    def get_solvable_location():
 311        """
 312        Provides the directory to store SAT solvables for repositories.
 313        The solvable files are used to perform package
 314        dependency and metadata resolution
 315
 316        :return: directory path
 317
 318        :rtype: str
 319        """
 320        return '/var/tmp/kiwi/satsolver'
 321
 322    @staticmethod
 323    def set_runtime_checker_metadata(filename):
 324        """
 325        Sets the runtime checker metadata filename
 326
 327        :param str filename: a file path name
 328        """
 329        global RUNTIME_CHECKER_METADATA
 330        RUNTIME_CHECKER_METADATA = filename
 331
 332    @staticmethod
 333    def set_shared_cache_location(location):
 334        """
 335        Sets the shared cache location once
 336
 337        :param str location: a location path
 338        """
 339        global SHARED_CACHE_DIR
 340        SHARED_CACHE_DIR = location
 341
 342    @staticmethod
 343    def set_custom_runtime_config_file(filename):
 344        """
 345        Sets the runtime config file once
 346
 347        :param str filename: a file path name
 348        """
 349        global CUSTOM_RUNTIME_CONFIG_FILE
 350        CUSTOM_RUNTIME_CONFIG_FILE = filename
 351
 352    @staticmethod
 353    def set_temp_location(location):
 354        """
 355        Sets the temp directory location once
 356
 357        :param str location: a location path
 358        """
 359        global TEMP_DIR
 360        TEMP_DIR = location
 361
 362    @staticmethod
 363    def get_shared_cache_location():
 364        """
 365        Provides the shared cache location
 366
 367        This is a directory which shares data from the image buildsystem
 368        host with the image root system. The location is returned as an
 369        absolute path stripped off by the leading '/'. This is because
 370        the path is transparently used on the host /<cache-dir> and
 371        inside of the image imageroot/<cache-dir>
 372
 373        :return: directory path
 374
 375        :rtype: str
 376        """
 377        return os.path.abspath(os.path.normpath(
 378            SHARED_CACHE_DIR
 379        )).lstrip(os.sep)
 380
 381    @staticmethod
 382    def get_temp_location():
 383        """
 384        Provides the base temp directory location
 385
 386        This is the directory used to store any temporary files
 387        and directories created by kiwi during runtime
 388
 389        :return: directory path
 390
 391        :rtype: str
 392        """
 393        return os.path.abspath(
 394            os.path.normpath(TEMP_DIR)
 395        )
 396
 397    @staticmethod
 398    def get_sync_options():
 399        """
 400        Provides list of default data sync options
 401
 402        :return: list of rsync options
 403
 404        :rtype: list
 405        """
 406        return [
 407            '--archive', '--hard-links', '--xattrs', '--acls',
 408            '--one-file-system', '--inplace'
 409        ]
 410
 411    @staticmethod
 412    def get_removed_files_name():
 413        """
 414        Provides base file name to store removed files
 415        in a delta root build
 416        """
 417        return 'removed'
 418
 419    @staticmethod
 420    def get_system_files_name():
 421        """
 422        Provides base file name to store system files
 423        in a container build
 424        """
 425        return 'systemfiles'
 426
 427    @staticmethod
 428    def get_exclude_list_for_removed_files_detection() -> List[str]:
 429        """
 430        Provides list of files/dirs to exclude from the removed
 431        files detection in a delta root build
 432        """
 433        return [
 434            'etc/hosts.kiwi',
 435            'etc/hosts.sha',
 436            'etc/resolv.conf.kiwi',
 437            'etc/resolv.conf.sha',
 438            'etc/sysconfig/proxy.kiwi',
 439            'etc/sysconfig/proxy.sha',
 440            'usr/lib/sysimage/rpm'
 441        ]
 442
 443    @staticmethod
 444    def get_exclude_list_for_root_data_sync(no_tmpdirs: bool = True):
 445        """
 446        Provides the list of files or folders that are created
 447        by KIWI for its own purposes. Those files should be not
 448        be included in the resulting image.
 449
 450        :return: list of file and directory names
 451
 452        :rtype: list
 453        """
 454        exclude_list = [
 455            'image', '.kconfig'
 456        ]
 457        if no_tmpdirs:
 458            exclude_list += ['run/*', 'tmp/*']
 459        exclude_list += [
 460            Defaults.get_buildservice_env_name(),
 461            Defaults.get_shared_cache_location()
 462        ]
 463        return exclude_list
 464
 465    @staticmethod
 466    def get_runtime_checker_metadata() -> Dict:
 467        with open(RUNTIME_CHECKER_METADATA) as meta:
 468            return yaml.safe_load(meta)
 469
 470    @staticmethod
 471    def _parse_exclude_file(root_dir: str, exclude_filename: str) -> List:
 472        """
 473        Retrieves an exclusion list from the provided metadata file
 474
 475        The file should contain a YAML dictionary with a top-level key
 476        named 'exclude' and the list of exclusions as its value.
 477
 478        The list of exclusions may include:
 479            * file paths
 480            * folder paths
 481            * glob patterns
 482
 483        Paths and patterns should be relative to the filesystem or
 484        directory that they're being excluded from.
 485
 486        :return: list of paths and glob patterns
 487
 488        :param string root_dir: image root directory
 489        :param string exclude_filename: file exclusion YAML metadata file
 490
 491        :rtype: list
 492        """
 493        exclude_file = os.sep.join(
 494            [root_dir, 'image', exclude_filename]
 495        )
 496        exclude_list = []
 497        if os.path.isfile(exclude_file):
 498            with open(exclude_file) as exclude:
 499                exclude_dict = yaml.safe_load(exclude)
 500                exclude_data = exclude_dict.get('exclude')
 501                if exclude_data and isinstance(exclude_data, list):
 502                    for exclude_file in exclude_data:
 503                        exclude_list.append(
 504                            exclude_file.lstrip(os.sep)
 505                        )
 506                else:
 507                    log.warning(
 508                        f'invalid yaml structure in {exclude_file}, ignored'
 509                    )
 510        return exclude_list
 511
 512    @staticmethod
 513    def get_exclude_list_from_custom_exclude_files(root_dir: str) -> List:
 514        """
 515        Gets the list of excluded items for the root filesystem from
 516        the optional metadata file image/exclude_files.yaml
 517
 518        :return: list of paths and glob patterns
 519
 520        :param string root_dir: image root directory
 521
 522        :rtype: list
 523        """
 524        return Defaults._parse_exclude_file(root_dir, 'exclude_files.yaml')
 525
 526    @staticmethod
 527    def get_exclude_list_from_custom_exclude_files_for_efifatimage(root_dir: str) -> List:
 528        """
 529        Gets the list of excluded items for the ESP's EFI folder from
 530        the optional metadata file image/exclude_files_efifatimage.yaml
 531
 532        Excluded items must be relative to the ESP's /EFI directory.
 533
 534        :return: list of paths and glob patterns
 535
 536        :param string root_dir: EFI root directory
 537
 538        :rtype: list
 539        """
 540        return Defaults._parse_exclude_file(root_dir, 'exclude_files_efifatimage.yaml')
 541
 542    @staticmethod
 543    def get_exclude_list_for_non_physical_devices():
 544        """
 545        Provides the list of folders that are not associated
 546        with a physical device. KIWI returns the basename of
 547        the folders typically used as mountpoint for those
 548        devices.
 549
 550        :return: list of file and directory names
 551
 552        :rtype: list
 553        """
 554        exclude_list = [
 555            'proc', 'sys', 'dev'
 556        ]
 557        return exclude_list
 558
 559    @staticmethod
 560    def get_failsafe_kernel_options():
 561        """
 562        Provides failsafe boot kernel options
 563
 564        :return:
 565            list of kernel options
 566
 567            .. code:: python
 568
 569                ['option=value', 'option']
 570
 571        :rtype: list
 572        """
 573        return ' '.join(
 574            [
 575                'ide=nodma',
 576                'apm=off',
 577                'noresume',
 578                'edd=off',
 579                'nomodeset',
 580                '3'
 581            ]
 582        )
 583
 584    @staticmethod
 585    def get_video_mode_map():
 586        """
 587        Provides video mode map
 588
 589        Assign a tuple to each kernel vesa hex id for each of the
 590        supported bootloaders
 591
 592        :return:
 593            video type map
 594
 595            .. code:: python
 596
 597                {'kernel_hex_mode': video_type(grub2='mode')}
 598
 599        :rtype: dict
 600        """
 601        video_type = namedtuple(
 602            'video_type', ['grub2']
 603        )
 604        return {
 605            '0x301': video_type(grub2='640x480'),
 606            '0x310': video_type(grub2='640x480'),
 607            '0x311': video_type(grub2='640x480'),
 608            '0x312': video_type(grub2='640x480'),
 609            '0x303': video_type(grub2='800x600'),
 610            '0x313': video_type(grub2='800x600'),
 611            '0x314': video_type(grub2='800x600'),
 612            '0x315': video_type(grub2='800x600'),
 613            '0x305': video_type(grub2='1024x768'),
 614            '0x316': video_type(grub2='1024x768'),
 615            '0x317': video_type(grub2='1024x768'),
 616            '0x318': video_type(grub2='1024x768'),
 617            '0x307': video_type(grub2='1280x1024'),
 618            '0x319': video_type(grub2='1280x1024'),
 619            '0x31a': video_type(grub2='1280x1024'),
 620            '0x31b': video_type(grub2='1280x1024'),
 621            'auto': video_type(grub2='auto')
 622        }
 623
 624    @staticmethod
 625    def get_volume_id():
 626        """
 627        Provides default value for ISO volume ID
 628
 629        :return: name
 630
 631        :rtype: str
 632        """
 633        return 'CDROM'
 634
 635    @staticmethod
 636    def get_install_volume_id():
 637        """
 638        Provides default value for ISO volume ID for install media
 639
 640        :return: name
 641
 642        :rtype: str
 643        """
 644        return 'INSTALL'
 645
 646    @staticmethod
 647    def get_snapper_config_template_file(root: str) -> str:
 648        """
 649        Provides the default configuration template file for snapper.
 650        The location in etc/ are preferred over files in usr/
 651
 652        :return: file path
 653
 654        :rtype: str
 655        """
 656        snapper_templates = [
 657            'etc/snapper/config-templates/default',
 658            'usr/share/snapper/config-templates/default'
 659        ]
 660        snapper_default_conf = ''
 661        for snapper_template in snapper_templates:
 662            template_config = os.path.join(root, snapper_template)
 663            if os.path.exists(template_config):
 664                snapper_default_conf = template_config
 665                break
 666        return snapper_default_conf
 667
 668    @staticmethod
 669    def get_default_video_mode():
 670        """
 671        Uses auto mode for default video. See get_video_mode_map
 672        for details on the value depending which bootloader is
 673        used
 674
 675        :return: auto
 676
 677        :rtype: str
 678        """
 679        return 'auto'
 680
 681    @staticmethod
 682    def get_default_bootloader():
 683        """
 684        Return default bootloader name which is grub2
 685
 686        :return: bootloader name
 687
 688        :rtype: str
 689        """
 690        return 'grub2'
 691
 692    @staticmethod
 693    def get_grub_custom_arguments(root_dir: str) -> Dict[str, str]:
 694        return {
 695            'grub_directory_name':
 696                Defaults.get_grub_boot_directory_name(root_dir),
 697            'grub_load_command':
 698                'configfile'
 699        }
 700
 701    @staticmethod
 702    def get_grub_boot_directory_name(lookup_path):
 703        """
 704        Provides grub2 data directory name in boot/ directory
 705
 706        Depending on the distribution the grub2 boot path could be
 707        either boot/grub2 or boot/grub. The method will decide for
 708        the correct base directory name according to the name pattern
 709        of the installed grub2 tools
 710
 711        :return: directory basename
 712
 713        :rtype: str
 714        """
 715        if Path.which(filename='grub2-install', root_dir=lookup_path):
 716            # the presence of grub2-install is an indicator to put all
 717            # grub2 data below boot/grub2
 718            return 'grub2'
 719        else:
 720            # in any other case the assumption is made that all grub
 721            # boot data should live below boot/grub
 722            return 'grub'
 723
 724    @staticmethod
 725    def get_grub_basic_modules(multiboot):
 726        """
 727        Provides list of basic grub modules
 728
 729        :param bool multiboot: grub multiboot mode
 730
 731        :return: list of module names
 732
 733        :rtype: list
 734        """
 735        modules = [
 736            'ext2',
 737            'iso9660',
 738            'linux',
 739            'echo',
 740            'configfile',
 741            'search_label',
 742            'search_fs_file',
 743            'search',
 744            'search_fs_uuid',
 745            'ls',
 746            'normal',
 747            'gzio',
 748            'png',
 749            'fat',
 750            'gettext',
 751            'font',
 752            'minicmd',
 753            'gfxterm',
 754            'gfxmenu',
 755            'all_video',
 756            'xfs',
 757            'btrfs',
 758            'squash4',
 759            'lvm',
 760            'luks',
 761            'gcry_rijndael',
 762            'gcry_sha256',
 763            'gcry_sha512',
 764            'crypto',
 765            'cryptodisk',
 766            'test',
 767            'true',
 768            'loadenv'
 769        ]
 770        if multiboot:
 771            modules.append('multiboot')
 772        return modules
 773
 774    @staticmethod
 775    def get_grub_efi_modules(multiboot=False):
 776        """
 777        Provides list of grub efi modules
 778
 779        :param bool multiboot: grub multiboot mode
 780
 781        :return: list of module names
 782
 783        :rtype: list
 784        """
 785        modules = Defaults.get_grub_basic_modules(multiboot) + [
 786            'part_gpt',
 787            'part_msdos',
 788            'efi_gop'
 789        ]
 790        return modules
 791
 792    @staticmethod
 793    def get_grub_platform_modules(multiboot=False):
 794        """
 795        Provides list of platform specific grub modules
 796
 797        :param bool multiboot: grub multiboot mode
 798
 799        :return: list of module names
 800
 801        :rtype: list
 802        """
 803        modules = Defaults.get_grub_basic_modules(multiboot)
 804        if Defaults.is_ppc64_arch(Defaults.get_platform_name()):
 805            return Defaults.get_grub_ofw_modules()
 806        else:
 807            modules += [
 808                'part_gpt',
 809                'part_msdos',
 810                'biosdisk',
 811                'vga',
 812                'vbe',
 813                'chain',
 814                'boot'
 815            ]
 816        return modules
 817
 818    @staticmethod
 819    def get_grub_ofw_modules():
 820        """
 821        Provides list of grub ofw modules (ppc)
 822
 823        :return: list of module names
 824
 825        :rtype: list
 826        """
 827        modules = Defaults.get_grub_basic_modules(multiboot=False) + [
 828            'part_gpt',
 829            'part_msdos',
 830            'boot'
 831        ]
 832        return modules
 833
 834    @staticmethod
 835    def get_grub_s390_modules():
 836        """
 837        Provides list of grub ofw modules (s390)
 838
 839        :return: list of module names
 840
 841        :rtype: list
 842        """
 843        modules = Defaults.get_grub_basic_modules(multiboot=False) + [
 844            'part_gpt',
 845            'part_msdos',
 846            'boot'
 847        ]
 848        return modules
 849
 850    @staticmethod
 851    def get_grub_path(
 852        root_path: str, filename: str, raise_on_error: bool = True
 853    ) -> str:
 854        """
 855        Provides grub path to given search file
 856
 857        Depending on the distribution grub could be installed below
 858        a grub2 or grub directory. grub could also reside in /usr/lib
 859        as well as in /usr/share. Therefore this information needs
 860        to be dynamically looked up
 861
 862        :param string root_path: root path to start the lookup from
 863        :param string filename: filename to search
 864        :param bool raise_on_error: raise on not found, defaults to True
 865
 866        The method returns the path to the given grub search file.
 867        By default it raises a KiwiBootLoaderGrubDataError exception
 868        if the file could not be found in any of the search locations.
 869        If raise_on_error is set to False and no file could be found
 870        the function returns None
 871
 872        :return: filepath
 873
 874        :rtype: str
 875        """
 876        log.debug(f'Searching grub file: {filename}')
 877        install_dirs = [
 878            'usr/share', 'usr/lib'
 879        ]
 880        lookup_list = []
 881        for grub_name in ['grub2', 'grub']:
 882            for install_dir in install_dirs:
 883                grub_path = os.path.join(
 884                    root_path, install_dir, grub_name, filename
 885                )
 886                log.debug(f'--> {grub_path}')
 887                if os.path.exists(grub_path):
 888                    log.debug(f'--> Found in: {grub_path}')
 889                    return grub_path
 890                lookup_list.append(grub_path)
 891        if raise_on_error:
 892            raise KiwiBootLoaderGrubDataError(
 893                'grub path {0} not found in {1}'.format(filename, lookup_list)
 894            )
 895        return ''
 896
 897    @staticmethod
 898    def get_preparer():
 899        """
 900        Provides ISO preparer name
 901
 902        :return: name
 903
 904        :rtype: str
 905        """
 906        return 'KIWI - https://github.com/OSInside/kiwi'
 907
 908    @staticmethod
 909    def get_publisher():
 910        """
 911        Provides ISO publisher name
 912
 913        :return: name
 914
 915        :rtype: str
 916        """
 917        return 'SUSE LINUX GmbH'
 918
 919    @staticmethod
 920    def get_shim_loader(root_path: str) -> List[shim_loader_type]:
 921        """
 922        Provides shim loader file path
 923
 924        Searches distribution specific locations to find shim.efi
 925        below the given root path
 926
 927        :param string root_path: image root path
 928
 929        :return: list of shim_loader_type
 930
 931        :rtype: list
 932        """
 933        result = []
 934        shim_pattern_type = namedtuple(
 935            'shim_pattern_type', ['pattern', 'binaryname']
 936        )
 937        shim_file_patterns = [
 938            shim_pattern_type(
 939                '/usr/lib/shim/shim*.efi.signed.latest',
 940                'bootx64.efi'
 941            ),
 942            shim_pattern_type(
 943                '/usr/lib/shim/shim*.efi.signed',
 944                'bootx64.efi'
 945            ),
 946            shim_pattern_type(
 947                '/usr/lib/grub/*-efi-signed',
 948                'bootx64.efi'
 949            ),
 950            shim_pattern_type(
 951                '/usr/share/efi/x86_64/shim.efi',
 952                'bootx64.efi'
 953            ),
 954            shim_pattern_type(
 955                '/usr/share/efi/aarch64/shim.efi',
 956                'bootaa64.efi'
 957            ),
 958            shim_pattern_type(
 959                '/usr/lib64/efi/shim.efi',
 960                'bootx64.efi'
 961            ),
 962            shim_pattern_type(
 963                '/boot/efi/EFI/*/shimx64.efi',
 964                'bootx64.efi'
 965            ),
 966            shim_pattern_type(
 967                '/boot/efi/EFI/*/shimia32.efi',
 968                'bootia32.efi'
 969            ),
 970            shim_pattern_type(
 971                '/boot/efi/EFI/*/shimaa64.efi',
 972                'bootaa64.efi'
 973            ),
 974            shim_pattern_type(
 975                '/boot/efi/EFI/*/shimriscv64.efi',
 976                'bootriscv64.efi'
 977            ),
 978            shim_pattern_type(
 979                '/boot/efi/EFI/*/shim.efi',
 980                'bootx64.efi'
 981            ),
 982            shim_pattern_type(
 983                '/usr/lib/shim/shim*.efi',
 984                'bootx64.efi'
 985            )
 986        ]
 987        for shim_file_pattern in shim_file_patterns:
 988            for shim_file in sorted(
 989                glob.iglob(root_path + shim_file_pattern.pattern), key=len
 990            ):
 991                result.append(
 992                    shim_loader_type(shim_file, shim_file_pattern.binaryname)
 993                )
 994                # one match only expected, per pattern
 995                break
 996        return result
 997
 998    @staticmethod
 999    def get_mok_manager(root_path: str) -> List[str]:
1000        """
1001        Provides Mok Manager file path
1002
1003        Searches distribution specific locations to find
1004        the Mok Manager EFI binary
1005
1006        :param str root_path: image root path
1007
1008        :return: file path or None
1009
1010        :rtype: str
1011        """
1012        result = []
1013        mok_manager_file_patterns = [
1014            '/usr/share/efi/*/MokManager.efi',
1015            '/usr/lib64/efi/MokManager.efi',
1016            '/boot/efi/EFI/*/mm*.efi',
1017            '/usr/lib/shim/mm*.efi'
1018        ]
1019        for mok_manager_file_pattern in mok_manager_file_patterns:
1020            for mm_file in glob.iglob(root_path + mok_manager_file_pattern):
1021                result.append(mm_file)
1022        return result
1023
1024    @staticmethod
1025    def get_grub_efi_font_directory(root_path):
1026        """
1027        Provides distribution specific EFI font directory used with grub.
1028
1029        :param string root_path: image root path
1030
1031        :return: file path or None
1032
1033        :rtype: str
1034        """
1035        font_dir_patterns = [
1036            '/boot/efi/EFI/*/fonts'
1037        ]
1038        for font_dir_pattern in font_dir_patterns:
1039            for font_dir in glob.iglob(root_path + font_dir_pattern):
1040                return font_dir
1041
1042    @staticmethod
1043    def get_unsigned_grub_loader(
1044        root_path: str, target_type: str = 'disk'
1045    ) -> List[grub_loader_type]:
1046        """
1047        Provides unsigned grub efi loader file path
1048
1049        Searches distribution specific locations to find a distro
1050        grub EFI binary within the given root path
1051
1052        :param string root_path: image root path
1053
1054        :return: list of grub_loader_type
1055
1056        :rtype: list
1057        """
1058        result = []
1059        grub_pattern_type = namedtuple(
1060            'grub_pattern_type', ['pattern', 'binaryname', 'targetname']
1061        )
1062        unsigned_grub_file_patterns = {
1063            'disk': [
1064                grub_pattern_type(
1065                    '/usr/share/grub*/x86_64-efi/grub.efi',
1066                    'grub.efi',
1067                    'bootx64.efi'
1068                ),
1069                grub_pattern_type(
1070                    '/usr/lib/grub*/x86_64-efi/grub.efi',
1071                    'grub.efi',
1072                    'bootx64.efi'
1073                ),
1074                grub_pattern_type(
1075                    '/boot/efi/EFI/*/grubx64.efi',
1076                    'grubx64.efi',
1077                    'bootx64.efi'
1078                ),
1079                grub_pattern_type(
1080                    '/boot/efi/EFI/*/grubia32.efi',
1081                    'grubia32.efi',
1082                    'bootia32.efi'
1083                ),
1084                grub_pattern_type(
1085                    '/boot/efi/EFI/*/grubaa64.efi',
1086                    'grubaa64.efi',
1087                    'bootaa64.efi'
1088                ),
1089                grub_pattern_type(
1090                    '/boot/efi/EFI/*/grubriscv64.efi',
1091                    'grubriscv64.efi',
1092                    'bootriscv64.efi'
1093                )
1094            ],
1095            'iso': [
1096                grub_pattern_type(
1097                    '/boot/efi/EFI/*/gcdx64.efi',
1098                    'grubx64.efi',
1099                    'bootx64.efi'
1100                ),
1101                grub_pattern_type(
1102                    '/usr/share/grub*/x86_64-efi/grub.efi',
1103                    'grub.efi',
1104                    'bootx64.efi'
1105                ),
1106                grub_pattern_type(
1107                    '/usr/lib/grub*/x86_64-efi/grub.efi',
1108                    'grub.efi',
1109                    'bootx64.efi'
1110                ),
1111                grub_pattern_type(
1112                    '/boot/efi/EFI/*/grubx64.efi',
1113                    'grubx64.efi',
1114                    'bootx64.efi'
1115                ),
1116                grub_pattern_type(
1117                    '/boot/efi/EFI/*/grubia32.efi',
1118                    'grubia32.efi',
1119                    'bootia32.efi'
1120                ),
1121                grub_pattern_type(
1122                    '/boot/efi/EFI/*/grubaa64.efi',
1123                    'grubaa64.efi',
1124                    'bootaa64.efi'
1125                ),
1126                grub_pattern_type(
1127                    '/boot/efi/EFI/*/grubriscv64.efi',
1128                    'grubriscv64.efi',
1129                    'bootriscv64.efi'
1130                )
1131            ]
1132        }
1133        for unsigned_grub_file_pattern in unsigned_grub_file_patterns[target_type]:
1134            for unsigned_grub_file in glob.iglob(
1135                root_path + unsigned_grub_file_pattern.pattern
1136            ):
1137                result.append(
1138                    grub_loader_type(
1139                        unsigned_grub_file,
1140                        unsigned_grub_file_pattern.binaryname,
1141                        unsigned_grub_file_pattern.targetname
1142                    )
1143                )
1144                # one match only expected, per pattern
1145                break
1146        return result
1147
1148    @staticmethod
1149    def get_grub_chrp_loader(boot_path: str) -> str:
1150        """
1151        Lookup CHRP boot loader (ppc)
1152
1153        :param string boot_path: boot path
1154
1155        :return: file base name
1156
1157        :rtype: str
1158        """
1159        for chrp_loader in ['grub.elf', 'core.elf']:
1160            for grub_chrp in glob.iglob(
1161                os.sep.join(
1162                    [boot_path, 'boot/grub*/powerpc-ieee1275', chrp_loader]
1163                )
1164            ):
1165                log.info(f'Found CHRP loader at: {grub_chrp}')
1166                return os.path.basename(grub_chrp)
1167        raise KiwiBootLoaderGrubDataError(
1168            f'CHRP loader not found in {boot_path}'
1169        )
1170
1171    @staticmethod
1172    def get_grub_platform_core_loader(root_path):
1173        """
1174        Provides grub bios image
1175
1176        Searches distribution specific locations to find the
1177        core bios image below the given root path
1178
1179        :param string root_path: image root path
1180
1181        :return: file path or None
1182
1183        :rtype: str
1184        """
1185        bios_grub_core_patterns = [
1186            '/usr/share/grub*/{0}/{1}'.format(
1187                Defaults.get_grub_platform_module_directory_name(),
1188                Defaults.get_grub_platform_image_name()
1189            ),
1190            '/usr/lib/grub*/{0}/{1}'.format(
1191                Defaults.get_grub_platform_module_directory_name(),
1192                Defaults.get_grub_platform_image_name()
1193            )
1194        ]
1195        for bios_grub_core_pattern in bios_grub_core_patterns:
1196            for bios_grub_core in glob.iglob(
1197                root_path + bios_grub_core_pattern
1198            ):
1199                return bios_grub_core
1200
1201    @staticmethod
1202    def get_iso_grub_loader():
1203        """
1204        Return name of eltorito grub image used as ISO loader
1205
1206        :return: file base name
1207
1208        :rtype: str
1209        """
1210        return 'eltorito.img'
1211
1212    @staticmethod
1213    def get_iso_grub_mbr():
1214        """
1215        Return name of hybrid MBR image used as ISO boot record
1216
1217        :return: file base name
1218
1219        :rtype: str
1220        """
1221        return 'boot_hybrid.img'
1222
1223    @staticmethod
1224    def get_signed_grub_loader(
1225        root_path: str, target_type: str = 'disk'
1226    ) -> List[grub_loader_type]:
1227        """
1228        Provides shim signed grub loader file path
1229
1230        Searches distribution specific locations to find a grub
1231        EFI binary within the given root path
1232
1233        :param str root_path: image root path
1234
1235        :return: list of grub_loader_type
1236
1237        :rtype: list
1238        """
1239        result = []
1240        grub_pattern_type = namedtuple(
1241            'grub_pattern_type', ['pattern', 'binaryname', 'targetname']
1242        )
1243        signed_grub_file_patterns = {
1244            'disk': [
1245                grub_pattern_type(
1246                    '/usr/share/efi/*/grub.efi',
1247                    'grub.efi',
1248                    'bootx64.efi'
1249                ),
1250                grub_pattern_type(
1251                    '/usr/lib64/efi/grub.efi',
1252                    'grub.efi',
1253                    'bootx64.efi'
1254                ),
1255                grub_pattern_type(
1256                    '/boot/efi/EFI/*/grubx64.efi',
1257                    'grubx64.efi',
1258                    'bootx64.efi'
1259                ),
1260                grub_pattern_type(
1261                    '/boot/efi/EFI/*/grubia32.efi',
1262                    'grubia32.efi',
1263                    'bootia32.efi'
1264                ),
1265                grub_pattern_type(
1266                    '/boot/efi/EFI/*/grubaa64.efi',
1267                    'grubaa64.efi',
1268                    'bootaa64.efi'
1269                ),
1270                grub_pattern_type(
1271                    '/boot/efi/EFI/*/grubriscv64.efi',
1272                    'grubriscv64.efi',
1273                    'bootriscv64.efi'
1274                ),
1275                grub_pattern_type(
1276                    '/usr/share/grub*/*-efi/grub.efi',
1277                    'grub.efi',
1278                    'bootx64.efi'
1279                ),
1280                grub_pattern_type(
1281                    '/usr/lib/grub/x86_64-efi-signed/grubx64.efi.signed',
1282                    'grubx64.efi',
1283                    'bootx64.efi'
1284                )
1285            ],
1286            'iso': [
1287                grub_pattern_type(
1288                    '/boot/efi/EFI/*/gcdx64.efi',
1289                    'grubx64.efi',
1290                    'bootx64.efi'
1291                ),
1292                grub_pattern_type(
1293                    '/boot/efi/EFI/*/gcdaa64.efi',
1294                    'grubaa64.efi',
1295                    'bootaa64.efi'
1296                ),
1297                grub_pattern_type(
1298                    '/usr/share/efi/x86_64/grub.efi',
1299                    'grub.efi',
1300                    'grubx64.efi'
1301                ),
1302                grub_pattern_type(
1303                    '/usr/share/efi/aarch64/grub.efi',
1304                    'grub.efi',
1305                    'grubaa64.efi'
1306                ),
1307                grub_pattern_type(
1308                    '/usr/lib64/efi/grub.efi',
1309                    'grub.efi',
1310                    'bootx64.efi'
1311                ),
1312                grub_pattern_type(
1313                    '/boot/efi/EFI/*/grubx64.efi',
1314                    'grubx64.efi',
1315                    'bootx64.efi'
1316                ),
1317                grub_pattern_type(
1318                    '/boot/efi/EFI/*/grubia32.efi',
1319                    'grubia32.efi',
1320                    'bootia32.efi'
1321                ),
1322                grub_pattern_type(
1323                    '/boot/efi/EFI/*/grubaa64.efi',
1324                    'grubaa64.efi',
1325                    'bootaa64.efi'
1326                ),
1327                grub_pattern_type(
1328                    '/boot/efi/EFI/*/grubriscv64.efi',
1329                    'grubriscv64.efi',
1330                    'bootriscv64.efi'
1331                ),
1332                grub_pattern_type(
1333                    '/usr/share/grub*/x86_64-efi/grub.efi',
1334                    'grub.efi',
1335                    'bootx64.efi'
1336                ),
1337                grub_pattern_type(
1338                    '/usr/lib/grub/x86_64-efi-signed/grubx64.efi.signed',
1339                    'grubx64.efi',
1340                    'bootx64.efi'
1341                )
1342            ]
1343        }
1344        for signed_grub in signed_grub_file_patterns[target_type]:
1345            for signed_grub_file in glob.iglob(root_path + signed_grub.pattern):
1346                result.append(
1347                    grub_loader_type(
1348                        signed_grub_file,
1349                        signed_grub.binaryname,
1350                        signed_grub.targetname
1351                    )
1352                )
1353                # one match only expected, per pattern
1354                break
1355        return result
1356
1357    @staticmethod
1358    def get_efi_vendor_directory(efi_path):
1359        """
1360        Provides EFI vendor directory if present
1361
1362        Looks up distribution specific EFI vendor directory
1363
1364        :param string root_path: path to efi mountpoint
1365
1366        :return: directory path or None
1367
1368        :rtype: str
1369        """
1370        efi_vendor_directories = [
1371            'EFI/fedora',
1372            'EFI/redhat',
1373            'EFI/centos',
1374            'EFI/almalinux',
1375            'EFI/opensuse',
1376            'EFI/ubuntu',
1377            'EFI/debian'
1378        ]
1379        for efi_vendor_directory in efi_vendor_directories:
1380            efi_vendor_directory = os.sep.join([efi_path, efi_vendor_directory])
1381            if os.path.exists(efi_vendor_directory):
1382                return efi_vendor_directory
1383
1384    @staticmethod
1385    def get_vendor_grubenv(efi_path):
1386        efi_vendor_directory = Defaults.get_efi_vendor_directory(efi_path)
1387        if efi_vendor_directory:
1388            grubenv = os.sep.join([efi_vendor_directory, 'grubenv'])
1389            if os.path.exists(grubenv):
1390                return grubenv
1391
1392    @staticmethod
1393    def get_shim_vendor_directory(root_path):
1394        """
1395        Provides shim vendor directory
1396
1397        Searches distribution specific locations to find shim.efi
1398        below the given root path and return the directory name
1399        to the file found
1400
1401        :param string root_path: image root path
1402
1403        :return: directory path or None
1404
1405        :rtype: str
1406        """
1407        shim_vendor_patterns = [
1408            '/boot/efi/EFI/*/shim*.efi',
1409            '/EFI/*/shim*.efi'
1410        ]
1411        for shim_vendor_pattern in shim_vendor_patterns:
1412            for shim_file in glob.iglob(root_path + shim_vendor_pattern):
1413                return os.path.dirname(shim_file)
1414
1415    @staticmethod
1416    def get_default_volume_group_name():
1417        """
1418        Provides default LVM volume group name
1419
1420        :return: name
1421
1422        :rtype: str
1423        """
1424        return 'systemVG'
1425
1426    @staticmethod
1427    def get_min_partition_mbytes():
1428        """
1429        Provides default minimum partition size in mbytes
1430
1431        :return: mbsize value
1432
1433        :rtype: int
1434        """
1435        return 10
1436
1437    @staticmethod
1438    def get_min_volume_mbytes(filesystem: str):
1439        """
1440        Provides default minimum LVM volume size in mbytes
1441        per filesystem
1442
1443        :return: mbsize value
1444
1445        :rtype: int
1446        """
1447        if filesystem == 'btrfs':
1448            return 120
1449        elif filesystem == 'xfs':
1450            return 300
1451        else:
1452            return 30
1453
1454    @staticmethod
1455    def get_lvm_overhead_mbytes():
1456        """
1457        Provides empiric LVM overhead size in mbytes
1458
1459        :return: mbsize value
1460
1461        :rtype: int
1462        """
1463        return 80
1464
1465    @staticmethod
1466    def get_default_boot_mbytes():
1467        """
1468        Provides default boot partition size in mbytes
1469
1470        :return: mbsize value
1471
1472        :rtype: int
1473        """
1474        return 300
1475
1476    @staticmethod
1477    def get_default_efi_boot_mbytes():
1478        """
1479        Provides default EFI partition size in mbytes
1480
1481        :return: mbsize value
1482
1483        :rtype: int
1484        """
1485        return 20
1486
1487    @staticmethod
1488    def get_recovery_spare_mbytes():
1489        """
1490        Provides spare size of recovery partition in mbytes
1491
1492        :return: mbsize value
1493
1494        :rtype: int
1495        """
1496        return 300
1497
1498    @staticmethod
1499    def get_default_legacy_bios_mbytes():
1500        """
1501        Provides default size of bios_grub partition in mbytes
1502
1503        :return: mbsize value
1504
1505        :rtype: int
1506        """
1507        return 2
1508
1509    @staticmethod
1510    def get_default_prep_mbytes():
1511        """
1512        Provides default size of prep partition in mbytes
1513
1514        :return: mbsize value
1515
1516        :rtype: int
1517        """
1518        return 8
1519
1520    @staticmethod
1521    def get_disk_format_types():
1522        """
1523        Provides supported disk format types
1524
1525        :return: disk types
1526
1527        :rtype: list
1528        """
1529        return [
1530            'gce',
1531            'qcow2',
1532            'vmdk',
1533            'ova',
1534            'meta',
1535            'vmx',
1536            'vhd',
1537            'vhdx',
1538            'vhdfixed',
1539            'vdi',
1540            'vagrant.libvirt.box',
1541            'vagrant.virtualbox.box',
1542            'oci'
1543        ]
1544
1545    @staticmethod
1546    def get_vagrant_config_virtualbox_guest_additions():
1547        """
1548        Provides the default value for
1549        ``vagrantconfig.virtualbox_guest_additions_present``
1550
1551        :return: whether guest additions are expected to be present in the
1552            vagrant box
1553
1554        :rtype: bool
1555        """
1556        return False
1557
1558    @staticmethod
1559    def get_firmware_types():
1560        """
1561        Provides supported architecture specific firmware types
1562
1563        :return: firmware types per architecture
1564
1565        :rtype: dict
1566        """
1567        return {
1568            'x86_64': ['efi', 'uefi', 'bios', 'ec2'],
1569            'i586': ['bios'],
1570            'i686': ['bios'],
1571            'ix86': ['bios'],
1572            'aarch64': ['efi', 'uefi'],
1573            'arm64': ['efi', 'uefi'],
1574            'armv5el': ['efi', 'uefi'],
1575            'armv5tel': ['efi', 'uefi'],
1576            'armv6hl': ['efi', 'uefi'],
1577            'armv6l': ['efi', 'uefi'],
1578            'armv7hl': ['efi', 'uefi'],
1579            'armv7l': ['efi', 'uefi'],
1580            'armv8l': ['efi', 'uefi'],
1581            'loongarch64': ['efi', 'uefi'],
1582            'ppc': ['ofw'],
1583            'ppc64': ['ofw', 'opal'],
1584            'ppc64le': ['ofw', 'opal'],
1585            'riscv64': ['efi', 'uefi'],
1586            's390': [],
1587            's390x': []
1588        }
1589
1590    @staticmethod
1591    def get_default_firmware(arch):
1592        """
1593        Provides default firmware for specified architecture
1594
1595        :param string arch: machine architecture name
1596
1597        :return: firmware name
1598
1599        :rtype: str
1600        """
1601        default_firmware = {
1602            'x86_64': 'bios',
1603            'i586': 'bios',
1604            'i686': 'bios',
1605            'ix86': 'bios',
1606            'loongarch64': 'efi',
1607            'ppc': 'ofw',
1608            'ppc64': 'ofw',
1609            'ppc64le': 'ofw',
1610            'arm64': 'efi',
1611            'aarch64': 'efi',
1612            'armv5el': 'efi',
1613            'armv5tel': 'efi',
1614            'armv6hl': 'efi',
1615            'armv6l': 'efi',
1616            'armv7hl': 'efi',
1617            'armv7l': 'efi',
1618            'armv8l': 'efi',
1619            'riscv64': 'efi'
1620        }
1621        if arch in default_firmware:
1622            return default_firmware[arch]
1623
1624    @staticmethod
1625    def get_efi_capable_firmware_names():
1626        """
1627        Provides list of EFI capable firmware names. These are
1628        those for which kiwi supports the creation of an EFI
1629        bootable disk image
1630
1631        :return: firmware names
1632
1633        :rtype: list
1634        """
1635        return ['efi', 'uefi']
1636
1637    @staticmethod
1638    def get_ec2_capable_firmware_names():
1639        """
1640        Provides list of EC2 capable firmware names. These are
1641        those for which kiwi supports the creation of disk images
1642        bootable within the Amazon EC2 public cloud
1643
1644        :return: firmware names
1645
1646        :rtype: list
1647        """
1648        return ['ec2']
1649
1650    @staticmethod
1651    def get_efi_module_directory_name(arch):
1652        """
1653        Provides architecture specific EFI directory name which
1654        stores the EFI binaries for the desired architecture.
1655
1656        :param string arch: machine architecture name
1657
1658        :return: directory name
1659
1660        :rtype: str
1661        """
1662        default_module_directory_names = {
1663            'x86_64': 'x86_64-efi',
1664            'i386': 'i386-efi',
1665
1666            # There is no dedicated xen architecture but there are
1667            # modules provided for xen. Thus we treat it as an
1668            # architecture
1669            'x86_64_xen': 'x86_64-xen',
1670
1671            'aarch64': 'arm64-efi',
1672            'arm64': 'arm64-efi',
1673            'armv5el': 'arm-efi',
1674            'armv5tel': 'arm-efi',
1675            'armv6l': 'arm-efi',
1676            'armv7l': 'arm-efi',
1677            'armv8l': 'arm-efi',
1678            'loongarch64': 'loongarch64-efi',
1679            'riscv64': 'riscv64-efi'
1680        }
1681        if arch in default_module_directory_names:
1682            return default_module_directory_names[arch]
1683
1684    @staticmethod
1685    def get_grub_platform_module_directory_name():
1686        """
1687        Provides grub platform specific directory name which
1688        stores the grub module binaries
1689
1690        :return: directory name
1691
1692        :rtype: str
1693        """
1694        return 'powerpc-ieee1275' if Defaults.is_ppc64_arch(
1695            Defaults.get_platform_name()
1696        ) else 'i386-pc'
1697
1698    @staticmethod
1699    def get_efi_image_name(arch):
1700        """
1701        Provides architecture specific EFI boot binary name
1702
1703        :param string arch: machine architecture name
1704
1705        :return: name
1706
1707        :rtype: str
1708        """
1709        default_efi_image_names = {
1710            'x86_64': 'bootx64.efi',
1711            'i386': 'bootia32.efi',
1712            'aarch64': 'bootaa64.efi',
1713            'arm64': 'bootaa64.efi',
1714            'armv5el': 'bootarm.efi',
1715            'armv5tel': 'bootarm.efi',
1716            'armv6l': 'bootarm.efi',
1717            'armv7l': 'bootarm.efi',
1718            'armv8l': 'bootarm.efi',
1719            'loongarch64': 'bootloongarch64.efi',
1720            'riscv64': 'bootriscv64.efi'
1721        }
1722        if arch in default_efi_image_names:
1723            return default_efi_image_names[arch]
1724
1725    @staticmethod
1726    def get_grub_platform_image_name():
1727        """
1728        Provides platform specific core boot binary name
1729
1730        :return: name
1731
1732        :rtype: str
1733        """
1734        return 'grub.elf' if Defaults.is_ppc64_arch(
1735            Defaults.get_platform_name()
1736        ) else 'core.img'
1737
1738    @staticmethod
1739    def get_default_boot_timeout_seconds():
1740        """
1741        Provides default boot timeout in seconds
1742
1743        :return: seconds
1744
1745        :rtype: int
1746        """
1747        return 10
1748
1749    @staticmethod
1750    def get_default_disk_start_sector():
1751        """
1752        Provides the default initial disk sector for the first disk
1753        partition.
1754
1755        :return: sector value
1756
1757        :rtype: int
1758        """
1759        return Defaults().defaults['kiwi_startsector']
1760
1761    @staticmethod
1762    def get_default_efi_partition_table_type():
1763        """
1764        Provides the default partition table type for efi firmwares.
1765
1766        :return: partition table type name
1767
1768        :rtype: str
1769        """
1770        return 'gpt'
1771
1772    @staticmethod
1773    def get_default_inode_size():
1774        """
1775        Provides default size of inodes in bytes. This is only
1776        relevant for inode based filesystems
1777
1778        :return: bytesize value
1779
1780        :rtype: int
1781        """
1782        return Defaults().defaults['kiwi_inode_size']
1783
1784    @staticmethod
1785    def get_archive_image_types():
1786        """
1787        Provides list of supported archive image types
1788
1789        :return: archive names
1790
1791        :rtype: list
1792        """
1793        return ['tbz', 'cpio']
1794
1795    @staticmethod
1796    def get_container_image_types():
1797        """
1798        Provides list of supported container image types
1799
1800        :return: container names
1801
1802        :rtype: list
1803        """
1804        return ['docker', 'oci', 'appx', 'wsl']
1805
1806    @staticmethod
1807    def get_filesystem_image_types():
1808        """
1809        Provides list of supported filesystem image types
1810
1811        :return: filesystem names
1812
1813        :rtype: list
1814        """
1815        return [
1816            'ext2', 'ext3', 'ext4', 'btrfs', 'squashfs',
1817            'xfs', 'fat16', 'fat32', 'erofs'
1818        ]
1819
1820    @staticmethod
1821    def get_default_live_iso_type():
1822        """
1823        Provides default live iso union type
1824
1825        :return: live iso type
1826
1827        :rtype: str
1828        """
1829        return 'overlay'
1830
1831    @staticmethod
1832    def get_default_uri_type():
1833        """
1834        Provides default URI type
1835
1836        Absolute path specifications used in the context of an URI
1837        will apply the specified default mime type
1838
1839        :return: URI mime type
1840
1841        :rtype: str
1842        """
1843        return 'dir:/'
1844
1845    @staticmethod
1846    def get_dracut_conf_name():
1847        """
1848        Provides file path of dracut config file to be used with KIWI
1849
1850        :return: file path name
1851
1852        :rtype: str
1853        """
1854        return '/etc/dracut.conf.d/02-kiwi.conf'
1855
1856    @staticmethod
1857    def get_live_dracut_modules_from_flag(flag_name):
1858        """
1859        Provides flag_name to dracut modules name map
1860
1861        Depending on the value of the flag attribute in the KIWI image
1862        description specific dracut modules need to be selected
1863
1864        :return: dracut module names as list
1865
1866        :rtype: list
1867        """
1868        live_modules = {
1869            'overlay': ['kiwi-live'],
1870            'dmsquash': ['dmsquash-live', 'livenet']
1871        }
1872        if flag_name in live_modules:
1873            return live_modules[flag_name]
1874        else:
1875            return ['kiwi-live']
1876
1877    @staticmethod
1878    def get_default_live_iso_root_filesystem():
1879        """
1880        Provides default live iso root filesystem type
1881
1882        :return: filesystem name
1883
1884        :rtype: str
1885        """
1886        return 'ext4'
1887
1888    @staticmethod
1889    def get_live_iso_persistent_boot_options(persistent_filesystem=None):
1890        """
1891        Provides list of boot options passed to the dracut
1892        kiwi-live module to setup persistent writing
1893
1894        :return: list of boot options
1895
1896        :rtype: list
1897        """
1898        live_iso_persistent_boot_options = [
1899            'rd.live.overlay.persistent'
1900        ]
1901        if persistent_filesystem:
1902            live_iso_persistent_boot_options.append(
1903                'rd.live.overlay.cowfs={0}'.format(persistent_filesystem)
1904            )
1905        return live_iso_persistent_boot_options
1906
1907    @staticmethod
1908    def get_disk_image_types():
1909        """
1910        Provides supported disk image types
1911
1912        :return: disk image type names
1913
1914        :rtype: list
1915        """
1916        return ['oem']
1917
1918    @staticmethod
1919    def get_live_image_types():
1920        """
1921        Provides supported live image types
1922
1923        :return: live image type names
1924
1925        :rtype: list
1926        """
1927        return ['iso']
1928
1929    @staticmethod
1930    def get_kis_image_types():
1931        """
1932        Provides supported kis image types
1933
1934        :return: kis image type names
1935
1936        :rtype: list
1937        """
1938        return ['kis', 'pxe']
1939
1940    @staticmethod
1941    def get_enclaves_image_types():
1942        """
1943        Provides supported enclave(initrd-only) image types
1944
1945        :return: enclave image type names
1946
1947        :rtype: list
1948        """
1949        return ['enclave']
1950
1951    @staticmethod
1952    def get_boot_image_description_path():
1953        """
1954        Provides the path to find custom kiwi boot descriptions
1955
1956        :return: directory path
1957
1958        :rtype: str
1959        """
1960        return '/usr/share/kiwi/custom_boot'
1961
1962    @staticmethod
1963    def get_boot_image_strip_file():
1964        """
1965        Provides the file path to bootloader strip metadata.
1966        This file contains information about the files and directories
1967        automatically striped out from the kiwi initrd
1968
1969        :return: file path
1970
1971        :rtype: str
1972        """
1973        return Defaults.project_file('config/strip.xml')
1974
1975    @staticmethod
1976    def get_schema_file():
1977        """
1978        Provides file path to kiwi RelaxNG schema
1979
1980        :return: file path
1981
1982        :rtype: str
1983        """
1984        return Defaults.project_file('schema/kiwi.rng')
1985
1986    @staticmethod
1987    def get_common_functions_file():
1988        """
1989        Provides the file path to config functions metadata.
1990
1991        This file contains bash functions used for system
1992        configuration or in the boot code from the kiwi initrd
1993
1994        :return: file path
1995
1996        :rtype: str
1997        """
1998        return Defaults.project_file('config/functions.sh')
1999
2000    @staticmethod
2001    def get_xsl_stylesheet_file():
2002        """
2003        Provides the file path to the KIWI XSLT style sheets
2004
2005        :return: file path
2006
2007        :rtype: str
2008        """
2009        return Defaults.project_file('xsl/master.xsl')
2010
2011    @staticmethod
2012    def get_schematron_module_name():
2013        """
2014        Provides module name for XML SchemaTron validations
2015
2016        :return: python module name
2017
2018        :rtype: str
2019        """
2020        return 'lxml.isoschematron'
2021
2022    @staticmethod
2023    def project_file(filename):
2024        """
2025        Provides the python module base directory search path
2026
2027        The method uses the importlib.resources.path method to identify
2028        files and directories from the application
2029
2030        :param string filename: relative project file
2031
2032        :return: absolute file path name
2033
2034        :rtype: str
2035        """
2036        with as_file(importlib.resources.files('kiwi')) as path:
2037            return f'{path}/{filename}'
2038
2039    @staticmethod
2040    def get_imported_root_image(root_dir):
2041        """
2042        Provides the path to an imported root system image
2043
2044        If the image description specified a derived_from attribute
2045        the file from this attribute is copied into the root_dir
2046        using the name as provided by this method
2047
2048        :param string root_dir: image root directory
2049
2050        :return: file path name
2051
2052        :rtype: str
2053        """
2054        return os.sep.join([root_dir, 'image', 'imported_root'])
2055
2056    @staticmethod
2057    def get_iso_boot_path():
2058        """
2059        Provides arch specific relative path to boot files
2060        on kiwi iso filesystems
2061
2062        :return: relative path name
2063
2064        :rtype: str
2065        """
2066        return os.sep.join(
2067            ['boot', Defaults.get_platform_name()]
2068        )
2069
2070    @staticmethod
2071    def get_iso_tool_category():
2072        """
2073        Provides default iso tool category
2074
2075        :return: name
2076
2077        :rtype: str
2078        """
2079        return 'xorriso'
2080
2081    @staticmethod
2082    def get_iso_media_tag_tool():
2083        """
2084        Provides default iso media tag tool
2085
2086        :return: name
2087
2088        :rtype: str
2089        """
2090        return 'checkmedia'
2091
2092    @staticmethod
2093    def get_container_compression():
2094        """
2095        Provides default container compression
2096
2097        :return: True
2098
2099        :rtype: bool
2100        """
2101        return True
2102
2103    @staticmethod
2104    def get_default_container_name():
2105        """
2106        Provides the default container name.
2107
2108        :return: name
2109
2110        :rtype: str
2111        """
2112        return 'kiwi-container'
2113
2114    @staticmethod
2115    def get_container_base_image_tag():
2116        """
2117        Provides the tag used to identify base layers during the build
2118        of derived images.
2119
2120        :return: tag
2121
2122        :rtype: str
2123        """
2124        return 'base_layer'
2125
2126    @staticmethod
2127    def get_oci_archive_tool():
2128        """
2129        Provides the default OCI archive tool name.
2130
2131        :return: name
2132
2133        :rtype: str
2134        """
2135        return 'umoci'
2136
2137    @staticmethod
2138    def get_part_mapper_tool():
2139        """
2140        Provides the default partition mapper tool name.
2141
2142        :return: name
2143
2144        :rtype: str
2145        """
2146        host_architecture = Defaults.get_platform_name()
2147        if 's390' in host_architecture:
2148            return 'kpartx'
2149        return 'partx'
2150
2151    @staticmethod
2152    def get_default_container_tag():
2153        """
2154        Provides the default container tag.
2155
2156        :return: tag
2157
2158        :rtype: str
2159        """
2160        return 'latest'
2161
2162    @staticmethod
2163    def get_default_container_subcommand():
2164        """
2165        Provides the default container subcommand.
2166
2167        :return: command as a list of arguments
2168
2169        :rtype: list
2170        """
2171        return ['/bin/bash']
2172
2173    @staticmethod
2174    def get_default_container_created_by():
2175        """
2176        Provides the default 'created by' history entry for containers.
2177
2178        :return: the specific kiwi version used for the build
2179
2180        :rtype: str
2181        """
2182        return 'KIWI {0}'.format(__version__)
2183
2184    @staticmethod
2185    def get_custom_rpm_macros_path():
2186        """
2187        Returns the custom macros directory for the rpm database.
2188
2189        :return: path name
2190
2191        :rtype: str
2192        """
2193        return 'usr/lib/rpm/macros.d'
2194
2195    @staticmethod
2196    def get_custom_rpm_bootstrap_macro_name():
2197        """
2198        Returns the rpm bootstrap macro file name created
2199        in the custom rpm macros path
2200
2201        :return: filename
2202
2203        :rtype: str
2204        """
2205        return 'macros.kiwi-bootstrap-config'
2206
2207    @staticmethod
2208    def get_custom_rpm_image_macro_name():
2209        """
2210        Returns the rpm image macro file name created
2211        in the custom rpm macros path
2212
2213        :return: filename
2214
2215        :rtype: str
2216        """
2217        return 'macros.kiwi-image-config'
2218
2219    @staticmethod
2220    def get_default_package_manager() -> str:
2221        """
2222        Returns the default package manager name if none
2223        is configured in the image description
2224
2225        :return: package manager name
2226
2227        :rtype: str
2228        """
2229        return 'dnf4'
2230
2231    @staticmethod
2232    def get_default_packager_tool(package_manager):
2233        """
2234        Provides the packager tool according to the package manager
2235
2236        :param string package_manager: package manger name
2237
2238        :return: packager tool binary name
2239
2240        :rtype: str
2241        """
2242        rpm_based = ['zypper', 'dnf4', 'dnf5', 'microdnf']
2243        deb_based = ['apt']
2244        if package_manager in rpm_based:
2245            return 'rpm'
2246        elif package_manager in deb_based:
2247            return 'dpkg'
2248        elif package_manager == 'pacman':
2249            return 'pacman'
2250
2251    @staticmethod
2252    def get_discoverable_partition_ids() -> Dict[str, str]:
2253        """
2254        Provides arch specific partition UUIDs as defined
2255        by the UAPI group
2256
2257        :return: partition UUIDs
2258
2259        :rtype: dict
2260        """
2261        arch = Defaults.get_platform_name()
2262        part_uuids_archs = {
2263            'x86_64': {
2264                'root':
2265                    '4f68bce3e8cd4db196e7fbcaf984b709',
2266                'usr':
2267                    '8484680c952148c69c11b0720656f69e',
2268                'usr-verity':
2269                    '77ff5f63e7b64633acf41565b864c0e6'
2270            },
2271            'ix86': {
2272                'root':
2273                    '44479540f29741b29af7d131d5f0458a',
2274                'usr':
2275                    '75250d768cc6458ebd66bd47cc81a812',
2276                'usr-verity':
2277                    '8f461b0d14ee4e819aa9049b6fb97abd'
2278            },
2279            'aarch64': {
2280                'root':
2281                    'b921b0451df041c3af444c6f280d3fae',
2282                'usr':
2283                    'b0e01050ee5f4390949a9101b17104e9',
2284                'usr-verity':
2285                    '6e11a4e7fbca4dedb9e9e1a512bb664e'
2286            },
2287            'riscv64': {
2288                'root':
2289                    '72ec70a6cf7440e6bd494bda08e8f224',
2290                'usr':
2291                    'beaec34b8442439ba40b984381ed097d',
2292                'usr-verity':
2293                    '8f1056be9b0547c481d6be53128e5b54'
2294            }
2295        }
2296        part_uuids_arch = part_uuids_archs.get(arch) or {}
2297        return {
2298            'root':
2299                part_uuids_arch.get('root') or '',
2300            'usr':
2301                part_uuids_arch.get('usr') or '',
2302            'usr-verity':
2303                part_uuids_arch.get('usr-verity') or '',
2304            'usr-secondary':
2305                '75250d768cc6458ebd66bd47cc81a812',
2306            'usr-secondary-verity':
2307                '8f461b0d14ee4e819aa9049b6fb97abd',
2308            'esp':
2309                'c12a7328f81f11d2ba4b00a0c93ec93b',
2310            'xbootldr':
2311                'bc13c2ff59e64262a352b275fd6f7172',
2312            'swap':
2313                '0657fd6da4ab43c484e50933c84b4f4f',
2314            'home':
2315                '933ac7e12eb44f13b8440e14e2aef915',
2316            'srv':
2317                '3b8f842520e04f3b907f1a25a76f98e8',
2318            'var':
2319                '4d21b016b53445c2a9fb5c16e091fd2d',
2320            'tmp':
2321                '7ec6f5573bc54acab29316ef5df639d1',
2322            'user-home':
2323                '773f91ef66d449b5bd83d683bf40ad16',
2324            'linux-generic':
2325                '0fc63daf848347728e793d69d8477de4'
2326        }
2327
2328    @staticmethod
2329    def get_bls_loader_entries_dir() -> str:
2330        """
2331        Provide default loader entries directory for BLS loaders
2332
2333        :return: directory name
2334
2335        :rtype: str
2336        """
2337        return '/boot/loader/entries'
2338
2339    @staticmethod
2340    def get_apk_repo_config() -> str:
2341        """
2342        Repository file for apk
2343
2344        :return: file path name
2345
2346        :rtype: str
2347        """
2348        return '/etc/apk/repositories'
2349
2350    @staticmethod
2351    def get_ca_update_map(target_distribution) -> Optional[Dict[str, str]]:
2352        return CA_UPDATE_MAP.get(target_distribution)
2353
2354    @staticmethod
2355    def get_ca_target_distributions() -> List[str]:
2356        return sorted(CA_UPDATE_MAP.keys())
2357
2358    def get(self, key):
2359        """
2360        Implements get method for profile elements
2361
2362        :param string key: profile keyname
2363
2364        :return: key value
2365
2366        :rtype: str
2367        """
2368        if key in self.defaults:
2369            return self.defaults[key]
2370
2371    @staticmethod
2372    def get_profile_file(root_dir):
2373        """
2374        Return name of profile file for given root directory
2375        """
2376        return root_dir + '/.profile'
2377
2378    def to_profile(self, profile):
2379        """
2380        Implements method to add list of profile keys and their values
2381        to the specified instance of a Profile class
2382
2383        :param object profile: Profile instance
2384        """
2385        for key in sorted(self.profile_key_list):
2386            # Do not apply default values to any variable that was
2387            # already defined in the profile instance.
2388            cur_profile = profile.dot_profile
2389            if key not in cur_profile or cur_profile[key] is None:
2390                profile.add(key, self.get(key))