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_volume_id():
 586        """
 587        Provides default value for ISO volume ID
 588
 589        :return: name
 590
 591        :rtype: str
 592        """
 593        return 'CDROM'
 594
 595    @staticmethod
 596    def get_install_volume_id():
 597        """
 598        Provides default value for ISO volume ID for install media
 599
 600        :return: name
 601
 602        :rtype: str
 603        """
 604        return 'INSTALL'
 605
 606    @staticmethod
 607    def get_snapper_config_template_file(root: str) -> str:
 608        """
 609        Provides the default configuration template file for snapper.
 610        The location in etc/ are preferred over files in usr/
 611
 612        :return: file path
 613
 614        :rtype: str
 615        """
 616        snapper_templates = [
 617            'etc/snapper/config-templates/default',
 618            'usr/share/snapper/config-templates/default'
 619        ]
 620        snapper_default_conf = ''
 621        for snapper_template in snapper_templates:
 622            template_config = os.path.join(root, snapper_template)
 623            if os.path.exists(template_config):
 624                snapper_default_conf = template_config
 625                break
 626        return snapper_default_conf
 627
 628    @staticmethod
 629    def get_default_bootloader():
 630        """
 631        Return default bootloader name which is grub2
 632
 633        :return: bootloader name
 634
 635        :rtype: str
 636        """
 637        return 'grub2'
 638
 639    @staticmethod
 640    def get_grub_custom_arguments(root_dir: str) -> Dict[str, str]:
 641        return {
 642            'grub_directory_name':
 643                Defaults.get_grub_boot_directory_name(root_dir),
 644            'grub_load_command':
 645                'configfile'
 646        }
 647
 648    @staticmethod
 649    def get_grub_boot_directory_name(lookup_path):
 650        """
 651        Provides grub2 data directory name in boot/ directory
 652
 653        Depending on the distribution the grub2 boot path could be
 654        either boot/grub2 or boot/grub. The method will decide for
 655        the correct base directory name according to the name pattern
 656        of the installed grub2 tools
 657
 658        :return: directory basename
 659
 660        :rtype: str
 661        """
 662        if Path.which(filename='grub2-install', root_dir=lookup_path):
 663            # the presence of grub2-install is an indicator to put all
 664            # grub2 data below boot/grub2
 665            return 'grub2'
 666        else:
 667            # in any other case the assumption is made that all grub
 668            # boot data should live below boot/grub
 669            return 'grub'
 670
 671    @staticmethod
 672    def get_grub_basic_modules(multiboot):
 673        """
 674        Provides list of basic grub modules
 675
 676        :param bool multiboot: grub multiboot mode
 677
 678        :return: list of module names
 679
 680        :rtype: list
 681        """
 682        modules = [
 683            'ext2',
 684            'iso9660',
 685            'linux',
 686            'echo',
 687            'configfile',
 688            'search_label',
 689            'search_fs_file',
 690            'search',
 691            'search_fs_uuid',
 692            'ls',
 693            'normal',
 694            'gzio',
 695            'png',
 696            'fat',
 697            'gettext',
 698            'font',
 699            'minicmd',
 700            'gfxterm',
 701            'gfxmenu',
 702            'all_video',
 703            'xfs',
 704            'btrfs',
 705            'squash4',
 706            'lvm',
 707            'luks',
 708            'gcry_rijndael',
 709            'gcry_sha256',
 710            'gcry_sha512',
 711            'crypto',
 712            'cryptodisk',
 713            'test',
 714            'true',
 715            'loadenv'
 716        ]
 717        if multiboot:
 718            modules.append('multiboot')
 719        return modules
 720
 721    @staticmethod
 722    def get_grub_efi_modules(multiboot=False):
 723        """
 724        Provides list of grub efi modules
 725
 726        :param bool multiboot: grub multiboot mode
 727
 728        :return: list of module names
 729
 730        :rtype: list
 731        """
 732        modules = Defaults.get_grub_basic_modules(multiboot) + [
 733            'part_gpt',
 734            'part_msdos',
 735            'efi_gop'
 736        ]
 737        return modules
 738
 739    @staticmethod
 740    def get_grub_platform_modules(multiboot=False):
 741        """
 742        Provides list of platform specific grub modules
 743
 744        :param bool multiboot: grub multiboot mode
 745
 746        :return: list of module names
 747
 748        :rtype: list
 749        """
 750        modules = Defaults.get_grub_basic_modules(multiboot)
 751        if Defaults.is_ppc64_arch(Defaults.get_platform_name()):
 752            return Defaults.get_grub_ofw_modules()
 753        else:
 754            modules += [
 755                'part_gpt',
 756                'part_msdos',
 757                'biosdisk',
 758                'vga',
 759                'vbe',
 760                'chain',
 761                'boot'
 762            ]
 763        return modules
 764
 765    @staticmethod
 766    def get_grub_ofw_modules():
 767        """
 768        Provides list of grub ofw modules (ppc)
 769
 770        :return: list of module names
 771
 772        :rtype: list
 773        """
 774        modules = Defaults.get_grub_basic_modules(multiboot=False) + [
 775            'part_gpt',
 776            'part_msdos',
 777            'boot'
 778        ]
 779        return modules
 780
 781    @staticmethod
 782    def get_grub_s390_modules():
 783        """
 784        Provides list of grub ofw modules (s390)
 785
 786        :return: list of module names
 787
 788        :rtype: list
 789        """
 790        modules = Defaults.get_grub_basic_modules(multiboot=False) + [
 791            'part_gpt',
 792            'part_msdos',
 793            'boot'
 794        ]
 795        return modules
 796
 797    @staticmethod
 798    def get_grub_path(
 799        root_path: str, filename: str, raise_on_error: bool = True
 800    ) -> str:
 801        """
 802        Provides grub path to given search file
 803
 804        Depending on the distribution grub could be installed below
 805        a grub2 or grub directory. grub could also reside in /usr/lib
 806        as well as in /usr/share. Therefore this information needs
 807        to be dynamically looked up
 808
 809        :param string root_path: root path to start the lookup from
 810        :param string filename: filename to search
 811        :param bool raise_on_error: raise on not found, defaults to True
 812
 813        The method returns the path to the given grub search file.
 814        By default it raises a KiwiBootLoaderGrubDataError exception
 815        if the file could not be found in any of the search locations.
 816        If raise_on_error is set to False and no file could be found
 817        the function returns None
 818
 819        :return: filepath
 820
 821        :rtype: str
 822        """
 823        log.debug(f'Searching grub file: {filename}')
 824        install_dirs = [
 825            'usr/share', 'usr/lib'
 826        ]
 827        lookup_list = []
 828        for grub_name in ['grub2', 'grub']:
 829            for install_dir in install_dirs:
 830                grub_path = os.path.join(
 831                    root_path, install_dir, grub_name, filename
 832                )
 833                log.debug(f'--> {grub_path}')
 834                if os.path.exists(grub_path):
 835                    log.debug(f'--> Found in: {grub_path}')
 836                    return grub_path
 837                lookup_list.append(grub_path)
 838        if raise_on_error:
 839            raise KiwiBootLoaderGrubDataError(
 840                'grub path {0} not found in {1}'.format(filename, lookup_list)
 841            )
 842        return ''
 843
 844    @staticmethod
 845    def get_preparer():
 846        """
 847        Provides ISO preparer name
 848
 849        :return: name
 850
 851        :rtype: str
 852        """
 853        return 'KIWI - https://github.com/OSInside/kiwi'
 854
 855    @staticmethod
 856    def get_publisher():
 857        """
 858        Provides ISO publisher name
 859
 860        :return: name
 861
 862        :rtype: str
 863        """
 864        return 'SUSE LINUX GmbH'
 865
 866    @staticmethod
 867    def get_shim_loader(root_path: str) -> List[shim_loader_type]:
 868        """
 869        Provides shim loader file path
 870
 871        Searches distribution specific locations to find shim.efi
 872        below the given root path
 873
 874        :param string root_path: image root path
 875
 876        :return: list of shim_loader_type
 877
 878        :rtype: list
 879        """
 880        result = []
 881        shim_pattern_type = namedtuple(
 882            'shim_pattern_type', ['pattern', 'binaryname']
 883        )
 884        shim_file_patterns = [
 885            shim_pattern_type(
 886                '/usr/lib/shim/shim*.efi.signed.latest',
 887                'bootx64.efi'
 888            ),
 889            shim_pattern_type(
 890                '/usr/lib/shim/shim*.efi.signed',
 891                'bootx64.efi'
 892            ),
 893            shim_pattern_type(
 894                '/usr/lib/grub/*-efi-signed',
 895                'bootx64.efi'
 896            ),
 897            shim_pattern_type(
 898                '/usr/share/efi/x86_64/shim.efi',
 899                'bootx64.efi'
 900            ),
 901            shim_pattern_type(
 902                '/usr/share/efi/aarch64/shim.efi',
 903                'bootaa64.efi'
 904            ),
 905            shim_pattern_type(
 906                '/usr/lib64/efi/shim.efi',
 907                'bootx64.efi'
 908            ),
 909            shim_pattern_type(
 910                '/boot/efi/EFI/*/shimx64.efi',
 911                'bootx64.efi'
 912            ),
 913            shim_pattern_type(
 914                '/boot/efi/EFI/*/shimia32.efi',
 915                'bootia32.efi'
 916            ),
 917            shim_pattern_type(
 918                '/boot/efi/EFI/*/shimaa64.efi',
 919                'bootaa64.efi'
 920            ),
 921            shim_pattern_type(
 922                '/boot/efi/EFI/*/shimriscv64.efi',
 923                'bootriscv64.efi'
 924            ),
 925            shim_pattern_type(
 926                '/boot/efi/EFI/*/shim.efi',
 927                'bootx64.efi'
 928            ),
 929            shim_pattern_type(
 930                '/usr/lib/shim/shim*.efi',
 931                'bootx64.efi'
 932            )
 933        ]
 934        for shim_file_pattern in shim_file_patterns:
 935            for shim_file in sorted(
 936                glob.iglob(root_path + shim_file_pattern.pattern), key=len
 937            ):
 938                result.append(
 939                    shim_loader_type(shim_file, shim_file_pattern.binaryname)
 940                )
 941                # one match only expected, per pattern
 942                break
 943        return result
 944
 945    @staticmethod
 946    def get_mok_manager(root_path: str) -> List[str]:
 947        """
 948        Provides Mok Manager file path
 949
 950        Searches distribution specific locations to find
 951        the Mok Manager EFI binary
 952
 953        :param str root_path: image root path
 954
 955        :return: file path or None
 956
 957        :rtype: str
 958        """
 959        result = []
 960        mok_manager_file_patterns = [
 961            '/usr/share/efi/*/MokManager.efi',
 962            '/usr/lib64/efi/MokManager.efi',
 963            '/boot/efi/EFI/*/mm*.efi',
 964            '/usr/lib/shim/mm*.efi'
 965        ]
 966        for mok_manager_file_pattern in mok_manager_file_patterns:
 967            for mm_file in glob.iglob(root_path + mok_manager_file_pattern):
 968                result.append(mm_file)
 969        return result
 970
 971    @staticmethod
 972    def get_grub_efi_font_directory(root_path):
 973        """
 974        Provides distribution specific EFI font directory used with grub.
 975
 976        :param string root_path: image root path
 977
 978        :return: file path or None
 979
 980        :rtype: str
 981        """
 982        font_dir_patterns = [
 983            '/boot/efi/EFI/*/fonts'
 984        ]
 985        for font_dir_pattern in font_dir_patterns:
 986            for font_dir in glob.iglob(root_path + font_dir_pattern):
 987                return font_dir
 988
 989    @staticmethod
 990    def get_unsigned_grub_loader(
 991        root_path: str, target_type: str = 'disk'
 992    ) -> List[grub_loader_type]:
 993        """
 994        Provides unsigned grub efi loader file path
 995
 996        Searches distribution specific locations to find a distro
 997        grub EFI binary within the given root path
 998
 999        :param string root_path: image root path
1000
1001        :return: list of grub_loader_type
1002
1003        :rtype: list
1004        """
1005        result = []
1006        grub_pattern_type = namedtuple(
1007            'grub_pattern_type', ['pattern', 'binaryname', 'targetname']
1008        )
1009        unsigned_grub_file_patterns = {
1010            'disk': [
1011                grub_pattern_type(
1012                    '/usr/share/grub*/x86_64-efi/grub.efi',
1013                    'grub.efi',
1014                    'bootx64.efi'
1015                ),
1016                grub_pattern_type(
1017                    '/usr/lib/grub*/x86_64-efi/grub.efi',
1018                    'grub.efi',
1019                    'bootx64.efi'
1020                ),
1021                grub_pattern_type(
1022                    '/boot/efi/EFI/*/grubx64.efi',
1023                    'grubx64.efi',
1024                    'bootx64.efi'
1025                ),
1026                grub_pattern_type(
1027                    '/boot/efi/EFI/*/grubia32.efi',
1028                    'grubia32.efi',
1029                    'bootia32.efi'
1030                ),
1031                grub_pattern_type(
1032                    '/boot/efi/EFI/*/grubaa64.efi',
1033                    'grubaa64.efi',
1034                    'bootaa64.efi'
1035                ),
1036                grub_pattern_type(
1037                    '/boot/efi/EFI/*/grubriscv64.efi',
1038                    'grubriscv64.efi',
1039                    'bootriscv64.efi'
1040                )
1041            ],
1042            'iso': [
1043                grub_pattern_type(
1044                    '/boot/efi/EFI/*/gcdx64.efi',
1045                    'grubx64.efi',
1046                    'bootx64.efi'
1047                ),
1048                grub_pattern_type(
1049                    '/usr/share/grub*/x86_64-efi/grub.efi',
1050                    'grub.efi',
1051                    'bootx64.efi'
1052                ),
1053                grub_pattern_type(
1054                    '/usr/lib/grub*/x86_64-efi/grub.efi',
1055                    'grub.efi',
1056                    'bootx64.efi'
1057                ),
1058                grub_pattern_type(
1059                    '/boot/efi/EFI/*/grubx64.efi',
1060                    'grubx64.efi',
1061                    'bootx64.efi'
1062                ),
1063                grub_pattern_type(
1064                    '/boot/efi/EFI/*/grubia32.efi',
1065                    'grubia32.efi',
1066                    'bootia32.efi'
1067                ),
1068                grub_pattern_type(
1069                    '/boot/efi/EFI/*/grubaa64.efi',
1070                    'grubaa64.efi',
1071                    'bootaa64.efi'
1072                ),
1073                grub_pattern_type(
1074                    '/boot/efi/EFI/*/grubriscv64.efi',
1075                    'grubriscv64.efi',
1076                    'bootriscv64.efi'
1077                )
1078            ]
1079        }
1080        for unsigned_grub_file_pattern in unsigned_grub_file_patterns[target_type]:
1081            for unsigned_grub_file in glob.iglob(
1082                root_path + unsigned_grub_file_pattern.pattern
1083            ):
1084                result.append(
1085                    grub_loader_type(
1086                        unsigned_grub_file,
1087                        unsigned_grub_file_pattern.binaryname,
1088                        unsigned_grub_file_pattern.targetname
1089                    )
1090                )
1091                # one match only expected, per pattern
1092                break
1093        return result
1094
1095    @staticmethod
1096    def get_grub_chrp_loader(boot_path: str) -> str:
1097        """
1098        Lookup CHRP boot loader (ppc)
1099
1100        :param string boot_path: boot path
1101
1102        :return: file base name
1103
1104        :rtype: str
1105        """
1106        for chrp_loader in ['grub.elf', 'core.elf']:
1107            for grub_chrp in glob.iglob(
1108                os.sep.join(
1109                    [boot_path, 'boot/grub*/powerpc-ieee1275', chrp_loader]
1110                )
1111            ):
1112                log.info(f'Found CHRP loader at: {grub_chrp}')
1113                return os.path.basename(grub_chrp)
1114        raise KiwiBootLoaderGrubDataError(
1115            f'CHRP loader not found in {boot_path}'
1116        )
1117
1118    @staticmethod
1119    def get_grub_platform_core_loader(root_path):
1120        """
1121        Provides grub bios image
1122
1123        Searches distribution specific locations to find the
1124        core bios image below the given root path
1125
1126        :param string root_path: image root path
1127
1128        :return: file path or None
1129
1130        :rtype: str
1131        """
1132        bios_grub_core_patterns = [
1133            '/usr/share/grub*/{0}/{1}'.format(
1134                Defaults.get_grub_platform_module_directory_name(),
1135                Defaults.get_grub_platform_image_name()
1136            ),
1137            '/usr/lib/grub*/{0}/{1}'.format(
1138                Defaults.get_grub_platform_module_directory_name(),
1139                Defaults.get_grub_platform_image_name()
1140            )
1141        ]
1142        for bios_grub_core_pattern in bios_grub_core_patterns:
1143            for bios_grub_core in glob.iglob(
1144                root_path + bios_grub_core_pattern
1145            ):
1146                return bios_grub_core
1147
1148    @staticmethod
1149    def get_iso_grub_loader():
1150        """
1151        Return name of eltorito grub image used as ISO loader
1152
1153        :return: file base name
1154
1155        :rtype: str
1156        """
1157        return 'eltorito.img'
1158
1159    @staticmethod
1160    def get_iso_grub_mbr():
1161        """
1162        Return name of hybrid MBR image used as ISO boot record
1163
1164        :return: file base name
1165
1166        :rtype: str
1167        """
1168        return 'boot_hybrid.img'
1169
1170    @staticmethod
1171    def get_signed_grub_loader(
1172        root_path: str, target_type: str = 'disk'
1173    ) -> List[grub_loader_type]:
1174        """
1175        Provides shim signed grub loader file path
1176
1177        Searches distribution specific locations to find a grub
1178        EFI binary within the given root path
1179
1180        :param str root_path: image root path
1181
1182        :return: list of grub_loader_type
1183
1184        :rtype: list
1185        """
1186        result = []
1187        grub_pattern_type = namedtuple(
1188            'grub_pattern_type', ['pattern', 'binaryname', 'targetname']
1189        )
1190        signed_grub_file_patterns = {
1191            'disk': [
1192                grub_pattern_type(
1193                    '/usr/share/efi/*/grub.efi',
1194                    'grub.efi',
1195                    'bootx64.efi'
1196                ),
1197                grub_pattern_type(
1198                    '/usr/lib64/efi/grub.efi',
1199                    'grub.efi',
1200                    'bootx64.efi'
1201                ),
1202                grub_pattern_type(
1203                    '/boot/efi/EFI/*/grubx64.efi',
1204                    'grubx64.efi',
1205                    'bootx64.efi'
1206                ),
1207                grub_pattern_type(
1208                    '/boot/efi/EFI/*/grubia32.efi',
1209                    'grubia32.efi',
1210                    'bootia32.efi'
1211                ),
1212                grub_pattern_type(
1213                    '/boot/efi/EFI/*/grubaa64.efi',
1214                    'grubaa64.efi',
1215                    'bootaa64.efi'
1216                ),
1217                grub_pattern_type(
1218                    '/boot/efi/EFI/*/grubriscv64.efi',
1219                    'grubriscv64.efi',
1220                    'bootriscv64.efi'
1221                ),
1222                grub_pattern_type(
1223                    '/usr/share/grub*/*-efi/grub.efi',
1224                    'grub.efi',
1225                    'bootx64.efi'
1226                ),
1227                grub_pattern_type(
1228                    '/usr/lib/grub/x86_64-efi-signed/grubx64.efi.signed',
1229                    'grubx64.efi',
1230                    'bootx64.efi'
1231                )
1232            ],
1233            'iso': [
1234                grub_pattern_type(
1235                    '/boot/efi/EFI/*/gcdx64.efi',
1236                    'grubx64.efi',
1237                    'bootx64.efi'
1238                ),
1239                grub_pattern_type(
1240                    '/boot/efi/EFI/*/gcdaa64.efi',
1241                    'grubaa64.efi',
1242                    'bootaa64.efi'
1243                ),
1244                grub_pattern_type(
1245                    '/usr/share/efi/x86_64/grub.efi',
1246                    'grub.efi',
1247                    'grubx64.efi'
1248                ),
1249                grub_pattern_type(
1250                    '/usr/share/efi/aarch64/grub.efi',
1251                    'grub.efi',
1252                    'grubaa64.efi'
1253                ),
1254                grub_pattern_type(
1255                    '/usr/lib64/efi/grub.efi',
1256                    'grub.efi',
1257                    'bootx64.efi'
1258                ),
1259                grub_pattern_type(
1260                    '/boot/efi/EFI/*/grubx64.efi',
1261                    'grubx64.efi',
1262                    'bootx64.efi'
1263                ),
1264                grub_pattern_type(
1265                    '/boot/efi/EFI/*/grubia32.efi',
1266                    'grubia32.efi',
1267                    'bootia32.efi'
1268                ),
1269                grub_pattern_type(
1270                    '/boot/efi/EFI/*/grubaa64.efi',
1271                    'grubaa64.efi',
1272                    'bootaa64.efi'
1273                ),
1274                grub_pattern_type(
1275                    '/boot/efi/EFI/*/grubriscv64.efi',
1276                    'grubriscv64.efi',
1277                    'bootriscv64.efi'
1278                ),
1279                grub_pattern_type(
1280                    '/usr/share/grub*/x86_64-efi/grub.efi',
1281                    'grub.efi',
1282                    'bootx64.efi'
1283                ),
1284                grub_pattern_type(
1285                    '/usr/lib/grub/x86_64-efi-signed/grubx64.efi.signed',
1286                    'grubx64.efi',
1287                    'bootx64.efi'
1288                )
1289            ]
1290        }
1291        for signed_grub in signed_grub_file_patterns[target_type]:
1292            for signed_grub_file in glob.iglob(root_path + signed_grub.pattern):
1293                result.append(
1294                    grub_loader_type(
1295                        signed_grub_file,
1296                        signed_grub.binaryname,
1297                        signed_grub.targetname
1298                    )
1299                )
1300                # one match only expected, per pattern
1301                break
1302        return result
1303
1304    @staticmethod
1305    def get_efi_vendor_directory(efi_path):
1306        """
1307        Provides EFI vendor directory if present
1308
1309        Looks up distribution specific EFI vendor directory
1310
1311        :param string root_path: path to efi mountpoint
1312
1313        :return: directory path or None
1314
1315        :rtype: str
1316        """
1317        efi_vendor_directories = [
1318            'EFI/fedora',
1319            'EFI/redhat',
1320            'EFI/centos',
1321            'EFI/almalinux',
1322            'EFI/opensuse',
1323            'EFI/ubuntu',
1324            'EFI/debian'
1325        ]
1326        for efi_vendor_directory in efi_vendor_directories:
1327            efi_vendor_directory = os.sep.join([efi_path, efi_vendor_directory])
1328            if os.path.exists(efi_vendor_directory):
1329                return efi_vendor_directory
1330
1331    @staticmethod
1332    def get_vendor_grubenv(efi_path):
1333        efi_vendor_directory = Defaults.get_efi_vendor_directory(efi_path)
1334        if efi_vendor_directory:
1335            grubenv = os.sep.join([efi_vendor_directory, 'grubenv'])
1336            if os.path.exists(grubenv):
1337                return grubenv
1338
1339    @staticmethod
1340    def get_shim_vendor_directory(root_path):
1341        """
1342        Provides shim vendor directory
1343
1344        Searches distribution specific locations to find shim.efi
1345        below the given root path and return the directory name
1346        to the file found
1347
1348        :param string root_path: image root path
1349
1350        :return: directory path or None
1351
1352        :rtype: str
1353        """
1354        shim_vendor_patterns = [
1355            '/boot/efi/EFI/*/shim*.efi',
1356            '/EFI/*/shim*.efi'
1357        ]
1358        for shim_vendor_pattern in shim_vendor_patterns:
1359            for shim_file in glob.iglob(root_path + shim_vendor_pattern):
1360                return os.path.dirname(shim_file)
1361
1362    @staticmethod
1363    def get_default_volume_group_name():
1364        """
1365        Provides default LVM volume group name
1366
1367        :return: name
1368
1369        :rtype: str
1370        """
1371        return 'systemVG'
1372
1373    @staticmethod
1374    def get_min_partition_mbytes():
1375        """
1376        Provides default minimum partition size in mbytes
1377
1378        :return: mbsize value
1379
1380        :rtype: int
1381        """
1382        return 10
1383
1384    @staticmethod
1385    def get_min_volume_mbytes(filesystem: str):
1386        """
1387        Provides default minimum LVM volume size in mbytes
1388        per filesystem
1389
1390        :return: mbsize value
1391
1392        :rtype: int
1393        """
1394        if filesystem == 'btrfs':
1395            return 120
1396        elif filesystem == 'xfs':
1397            return 300
1398        else:
1399            return 30
1400
1401    @staticmethod
1402    def get_lvm_overhead_mbytes():
1403        """
1404        Provides empiric LVM overhead size in mbytes
1405
1406        :return: mbsize value
1407
1408        :rtype: int
1409        """
1410        return 80
1411
1412    @staticmethod
1413    def get_default_boot_mbytes():
1414        """
1415        Provides default boot partition size in mbytes
1416
1417        :return: mbsize value
1418
1419        :rtype: int
1420        """
1421        return 300
1422
1423    @staticmethod
1424    def get_default_efi_boot_mbytes():
1425        """
1426        Provides default EFI partition size in mbytes
1427
1428        :return: mbsize value
1429
1430        :rtype: int
1431        """
1432        return 20
1433
1434    @staticmethod
1435    def get_recovery_spare_mbytes():
1436        """
1437        Provides spare size of recovery partition in mbytes
1438
1439        :return: mbsize value
1440
1441        :rtype: int
1442        """
1443        return 300
1444
1445    @staticmethod
1446    def get_default_legacy_bios_mbytes():
1447        """
1448        Provides default size of bios_grub partition in mbytes
1449
1450        :return: mbsize value
1451
1452        :rtype: int
1453        """
1454        return 2
1455
1456    @staticmethod
1457    def get_default_prep_mbytes():
1458        """
1459        Provides default size of prep partition in mbytes
1460
1461        :return: mbsize value
1462
1463        :rtype: int
1464        """
1465        return 8
1466
1467    @staticmethod
1468    def get_disk_format_types():
1469        """
1470        Provides supported disk format types
1471
1472        :return: disk types
1473
1474        :rtype: list
1475        """
1476        return [
1477            'gce',
1478            'qcow2',
1479            'vmdk',
1480            'ova',
1481            'meta',
1482            'vmx',
1483            'vhd',
1484            'vhdx',
1485            'vhdfixed',
1486            'vdi',
1487            'vagrant.libvirt.box',
1488            'vagrant.virtualbox.box',
1489            'oci'
1490        ]
1491
1492    @staticmethod
1493    def get_vagrant_config_virtualbox_guest_additions():
1494        """
1495        Provides the default value for
1496        ``vagrantconfig.virtualbox_guest_additions_present``
1497
1498        :return: whether guest additions are expected to be present in the
1499            vagrant box
1500
1501        :rtype: bool
1502        """
1503        return False
1504
1505    @staticmethod
1506    def get_firmware_types():
1507        """
1508        Provides supported architecture specific firmware types
1509
1510        :return: firmware types per architecture
1511
1512        :rtype: dict
1513        """
1514        return {
1515            'x86_64': ['efi', 'uefi', 'bios', 'ec2'],
1516            'i586': ['bios'],
1517            'i686': ['bios'],
1518            'ix86': ['bios'],
1519            'aarch64': ['efi', 'uefi'],
1520            'arm64': ['efi', 'uefi'],
1521            'armv5el': ['efi', 'uefi'],
1522            'armv5tel': ['efi', 'uefi'],
1523            'armv6hl': ['efi', 'uefi'],
1524            'armv6l': ['efi', 'uefi'],
1525            'armv7hl': ['efi', 'uefi'],
1526            'armv7l': ['efi', 'uefi'],
1527            'armv8l': ['efi', 'uefi'],
1528            'loongarch64': ['efi', 'uefi'],
1529            'ppc': ['ofw'],
1530            'ppc64': ['ofw', 'opal'],
1531            'ppc64le': ['ofw', 'opal'],
1532            'riscv64': ['efi', 'uefi'],
1533            's390': [],
1534            's390x': []
1535        }
1536
1537    @staticmethod
1538    def get_default_firmware(arch):
1539        """
1540        Provides default firmware for specified architecture
1541
1542        :param string arch: machine architecture name
1543
1544        :return: firmware name
1545
1546        :rtype: str
1547        """
1548        default_firmware = {
1549            'x86_64': 'bios',
1550            'i586': 'bios',
1551            'i686': 'bios',
1552            'ix86': 'bios',
1553            'loongarch64': 'efi',
1554            'ppc': 'ofw',
1555            'ppc64': 'ofw',
1556            'ppc64le': 'ofw',
1557            'arm64': 'efi',
1558            'aarch64': 'efi',
1559            'armv5el': 'efi',
1560            'armv5tel': 'efi',
1561            'armv6hl': 'efi',
1562            'armv6l': 'efi',
1563            'armv7hl': 'efi',
1564            'armv7l': 'efi',
1565            'armv8l': 'efi',
1566            'riscv64': 'efi'
1567        }
1568        if arch in default_firmware:
1569            return default_firmware[arch]
1570
1571    @staticmethod
1572    def get_efi_capable_firmware_names():
1573        """
1574        Provides list of EFI capable firmware names. These are
1575        those for which kiwi supports the creation of an EFI
1576        bootable disk image
1577
1578        :return: firmware names
1579
1580        :rtype: list
1581        """
1582        return ['efi', 'uefi']
1583
1584    @staticmethod
1585    def get_ec2_capable_firmware_names():
1586        """
1587        Provides list of EC2 capable firmware names. These are
1588        those for which kiwi supports the creation of disk images
1589        bootable within the Amazon EC2 public cloud
1590
1591        :return: firmware names
1592
1593        :rtype: list
1594        """
1595        return ['ec2']
1596
1597    @staticmethod
1598    def get_efi_module_directory_name(arch):
1599        """
1600        Provides architecture specific EFI directory name which
1601        stores the EFI binaries for the desired architecture.
1602
1603        :param string arch: machine architecture name
1604
1605        :return: directory name
1606
1607        :rtype: str
1608        """
1609        default_module_directory_names = {
1610            'x86_64': 'x86_64-efi',
1611            'i386': 'i386-efi',
1612
1613            # There is no dedicated xen architecture but there are
1614            # modules provided for xen. Thus we treat it as an
1615            # architecture
1616            'x86_64_xen': 'x86_64-xen',
1617
1618            'aarch64': 'arm64-efi',
1619            'arm64': 'arm64-efi',
1620            'armv5el': 'arm-efi',
1621            'armv5tel': 'arm-efi',
1622            'armv6l': 'arm-efi',
1623            'armv7l': 'arm-efi',
1624            'armv8l': 'arm-efi',
1625            'loongarch64': 'loongarch64-efi',
1626            'riscv64': 'riscv64-efi'
1627        }
1628        if arch in default_module_directory_names:
1629            return default_module_directory_names[arch]
1630
1631    @staticmethod
1632    def get_grub_platform_module_directory_name():
1633        """
1634        Provides grub platform specific directory name which
1635        stores the grub module binaries
1636
1637        :return: directory name
1638
1639        :rtype: str
1640        """
1641        return 'powerpc-ieee1275' if Defaults.is_ppc64_arch(
1642            Defaults.get_platform_name()
1643        ) else 'i386-pc'
1644
1645    @staticmethod
1646    def get_efi_image_name(arch):
1647        """
1648        Provides architecture specific EFI boot binary name
1649
1650        :param string arch: machine architecture name
1651
1652        :return: name
1653
1654        :rtype: str
1655        """
1656        default_efi_image_names = {
1657            'x86_64': 'bootx64.efi',
1658            'i386': 'bootia32.efi',
1659            'aarch64': 'bootaa64.efi',
1660            'arm64': 'bootaa64.efi',
1661            'armv5el': 'bootarm.efi',
1662            'armv5tel': 'bootarm.efi',
1663            'armv6l': 'bootarm.efi',
1664            'armv7l': 'bootarm.efi',
1665            'armv8l': 'bootarm.efi',
1666            'loongarch64': 'bootloongarch64.efi',
1667            'riscv64': 'bootriscv64.efi'
1668        }
1669        if arch in default_efi_image_names:
1670            return default_efi_image_names[arch]
1671
1672    @staticmethod
1673    def get_grub_platform_image_name():
1674        """
1675        Provides platform specific core boot binary name
1676
1677        :return: name
1678
1679        :rtype: str
1680        """
1681        return 'grub.elf' if Defaults.is_ppc64_arch(
1682            Defaults.get_platform_name()
1683        ) else 'core.img'
1684
1685    @staticmethod
1686    def get_default_boot_timeout_seconds():
1687        """
1688        Provides default boot timeout in seconds
1689
1690        :return: seconds
1691
1692        :rtype: int
1693        """
1694        return 10
1695
1696    @staticmethod
1697    def get_default_disk_start_sector():
1698        """
1699        Provides the default initial disk sector for the first disk
1700        partition.
1701
1702        :return: sector value
1703
1704        :rtype: int
1705        """
1706        return Defaults().defaults['kiwi_startsector']
1707
1708    @staticmethod
1709    def get_default_efi_partition_table_type():
1710        """
1711        Provides the default partition table type for efi firmwares.
1712
1713        :return: partition table type name
1714
1715        :rtype: str
1716        """
1717        return 'gpt'
1718
1719    @staticmethod
1720    def get_default_inode_size():
1721        """
1722        Provides default size of inodes in bytes. This is only
1723        relevant for inode based filesystems
1724
1725        :return: bytesize value
1726
1727        :rtype: int
1728        """
1729        return Defaults().defaults['kiwi_inode_size']
1730
1731    @staticmethod
1732    def get_archive_image_types():
1733        """
1734        Provides list of supported archive image types
1735
1736        :return: archive names
1737
1738        :rtype: list
1739        """
1740        return ['tbz', 'cpio']
1741
1742    @staticmethod
1743    def get_container_image_types():
1744        """
1745        Provides list of supported container image types
1746
1747        :return: container names
1748
1749        :rtype: list
1750        """
1751        return ['docker', 'oci', 'appx', 'wsl']
1752
1753    @staticmethod
1754    def get_filesystem_image_types():
1755        """
1756        Provides list of supported filesystem image types
1757
1758        :return: filesystem names
1759
1760        :rtype: list
1761        """
1762        return [
1763            'ext2', 'ext3', 'ext4', 'btrfs', 'squashfs',
1764            'xfs', 'fat16', 'fat32', 'erofs'
1765        ]
1766
1767    @staticmethod
1768    def get_default_live_iso_type():
1769        """
1770        Provides default live iso union type
1771
1772        :return: live iso type
1773
1774        :rtype: str
1775        """
1776        return 'overlay'
1777
1778    @staticmethod
1779    def get_default_uri_type():
1780        """
1781        Provides default URI type
1782
1783        Absolute path specifications used in the context of an URI
1784        will apply the specified default mime type
1785
1786        :return: URI mime type
1787
1788        :rtype: str
1789        """
1790        return 'dir:/'
1791
1792    @staticmethod
1793    def get_dracut_conf_name():
1794        """
1795        Provides file path of dracut config file to be used with KIWI
1796
1797        :return: file path name
1798
1799        :rtype: str
1800        """
1801        return '/etc/dracut.conf.d/02-kiwi.conf'
1802
1803    @staticmethod
1804    def get_live_dracut_modules_from_flag(flag_name):
1805        """
1806        Provides flag_name to dracut modules name map
1807
1808        Depending on the value of the flag attribute in the KIWI image
1809        description specific dracut modules need to be selected
1810
1811        :return: dracut module names as list
1812
1813        :rtype: list
1814        """
1815        live_modules = {
1816            'overlay': ['kiwi-live'],
1817            'dmsquash': ['dmsquash-live', 'livenet']
1818        }
1819        if flag_name in live_modules:
1820            return live_modules[flag_name]
1821        else:
1822            return ['kiwi-live']
1823
1824    @staticmethod
1825    def get_default_live_iso_root_filesystem():
1826        """
1827        Provides default live iso root filesystem type
1828
1829        :return: filesystem name
1830
1831        :rtype: str
1832        """
1833        return 'ext4'
1834
1835    @staticmethod
1836    def get_live_iso_persistent_boot_options(persistent_filesystem=None):
1837        """
1838        Provides list of boot options passed to the dracut
1839        kiwi-live module to setup persistent writing
1840
1841        :return: list of boot options
1842
1843        :rtype: list
1844        """
1845        live_iso_persistent_boot_options = [
1846            'rd.live.overlay.persistent'
1847        ]
1848        if persistent_filesystem:
1849            live_iso_persistent_boot_options.append(
1850                'rd.live.overlay.cowfs={0}'.format(persistent_filesystem)
1851            )
1852        return live_iso_persistent_boot_options
1853
1854    @staticmethod
1855    def get_disk_image_types():
1856        """
1857        Provides supported disk image types
1858
1859        :return: disk image type names
1860
1861        :rtype: list
1862        """
1863        return ['oem']
1864
1865    @staticmethod
1866    def get_live_image_types():
1867        """
1868        Provides supported live image types
1869
1870        :return: live image type names
1871
1872        :rtype: list
1873        """
1874        return ['iso']
1875
1876    @staticmethod
1877    def get_kis_image_types():
1878        """
1879        Provides supported kis image types
1880
1881        :return: kis image type names
1882
1883        :rtype: list
1884        """
1885        return ['kis', 'pxe']
1886
1887    @staticmethod
1888    def get_enclaves_image_types():
1889        """
1890        Provides supported enclave(initrd-only) image types
1891
1892        :return: enclave image type names
1893
1894        :rtype: list
1895        """
1896        return ['enclave']
1897
1898    @staticmethod
1899    def get_boot_image_description_path():
1900        """
1901        Provides the path to find custom kiwi boot descriptions
1902
1903        :return: directory path
1904
1905        :rtype: str
1906        """
1907        return '/usr/share/kiwi/custom_boot'
1908
1909    @staticmethod
1910    def get_boot_image_strip_file():
1911        """
1912        Provides the file path to bootloader strip metadata.
1913        This file contains information about the files and directories
1914        automatically striped out from the kiwi initrd
1915
1916        :return: file path
1917
1918        :rtype: str
1919        """
1920        return Defaults.project_file('config/strip.xml')
1921
1922    @staticmethod
1923    def get_schema_file():
1924        """
1925        Provides file path to kiwi RelaxNG schema
1926
1927        :return: file path
1928
1929        :rtype: str
1930        """
1931        return Defaults.project_file('schema/kiwi.rng')
1932
1933    @staticmethod
1934    def get_common_functions_file():
1935        """
1936        Provides the file path to config functions metadata.
1937
1938        This file contains bash functions used for system
1939        configuration or in the boot code from the kiwi initrd
1940
1941        :return: file path
1942
1943        :rtype: str
1944        """
1945        return Defaults.project_file('config/functions.sh')
1946
1947    @staticmethod
1948    def get_xsl_stylesheet_file():
1949        """
1950        Provides the file path to the KIWI XSLT style sheets
1951
1952        :return: file path
1953
1954        :rtype: str
1955        """
1956        return Defaults.project_file('xsl/master.xsl')
1957
1958    @staticmethod
1959    def get_schematron_module_name():
1960        """
1961        Provides module name for XML SchemaTron validations
1962
1963        :return: python module name
1964
1965        :rtype: str
1966        """
1967        return 'lxml.isoschematron'
1968
1969    @staticmethod
1970    def project_file(filename):
1971        """
1972        Provides the python module base directory search path
1973
1974        The method uses the importlib.resources.path method to identify
1975        files and directories from the application
1976
1977        :param string filename: relative project file
1978
1979        :return: absolute file path name
1980
1981        :rtype: str
1982        """
1983        with as_file(importlib.resources.files('kiwi')) as path:
1984            return f'{path}/{filename}'
1985
1986    @staticmethod
1987    def get_imported_root_image(root_dir):
1988        """
1989        Provides the path to an imported root system image
1990
1991        If the image description specified a derived_from attribute
1992        the file from this attribute is copied into the root_dir
1993        using the name as provided by this method
1994
1995        :param string root_dir: image root directory
1996
1997        :return: file path name
1998
1999        :rtype: str
2000        """
2001        return os.sep.join([root_dir, 'image', 'imported_root'])
2002
2003    @staticmethod
2004    def get_iso_boot_path():
2005        """
2006        Provides arch specific relative path to boot files
2007        on kiwi iso filesystems
2008
2009        :return: relative path name
2010
2011        :rtype: str
2012        """
2013        return os.sep.join(
2014            ['boot', Defaults.get_platform_name()]
2015        )
2016
2017    @staticmethod
2018    def get_iso_tool_category():
2019        """
2020        Provides default iso tool category
2021
2022        :return: name
2023
2024        :rtype: str
2025        """
2026        return 'xorriso'
2027
2028    @staticmethod
2029    def get_iso_media_tag_tool():
2030        """
2031        Provides default iso media tag tool
2032
2033        :return: name
2034
2035        :rtype: str
2036        """
2037        return 'checkmedia'
2038
2039    @staticmethod
2040    def get_container_compression():
2041        """
2042        Provides default container compression
2043
2044        :return: True
2045
2046        :rtype: bool
2047        """
2048        return True
2049
2050    @staticmethod
2051    def get_default_container_name():
2052        """
2053        Provides the default container name.
2054
2055        :return: name
2056
2057        :rtype: str
2058        """
2059        return 'kiwi-container'
2060
2061    @staticmethod
2062    def get_container_base_image_tag():
2063        """
2064        Provides the tag used to identify base layers during the build
2065        of derived images.
2066
2067        :return: tag
2068
2069        :rtype: str
2070        """
2071        return 'base_layer'
2072
2073    @staticmethod
2074    def get_oci_archive_tool():
2075        """
2076        Provides the default OCI archive tool name.
2077
2078        :return: name
2079
2080        :rtype: str
2081        """
2082        return 'umoci'
2083
2084    @staticmethod
2085    def get_part_mapper_tool():
2086        """
2087        Provides the default partition mapper tool name.
2088
2089        :return: name
2090
2091        :rtype: str
2092        """
2093        host_architecture = Defaults.get_platform_name()
2094        if 's390' in host_architecture:
2095            return 'kpartx'
2096        return 'partx'
2097
2098    @staticmethod
2099    def get_default_container_tag():
2100        """
2101        Provides the default container tag.
2102
2103        :return: tag
2104
2105        :rtype: str
2106        """
2107        return 'latest'
2108
2109    @staticmethod
2110    def get_default_container_subcommand():
2111        """
2112        Provides the default container subcommand.
2113
2114        :return: command as a list of arguments
2115
2116        :rtype: list
2117        """
2118        return ['/bin/bash']
2119
2120    @staticmethod
2121    def get_default_container_created_by():
2122        """
2123        Provides the default 'created by' history entry for containers.
2124
2125        :return: the specific kiwi version used for the build
2126
2127        :rtype: str
2128        """
2129        return 'KIWI {0}'.format(__version__)
2130
2131    @staticmethod
2132    def get_custom_rpm_macros_path():
2133        """
2134        Returns the custom macros directory for the rpm database.
2135
2136        :return: path name
2137
2138        :rtype: str
2139        """
2140        return 'usr/lib/rpm/macros.d'
2141
2142    @staticmethod
2143    def get_custom_rpm_bootstrap_macro_name():
2144        """
2145        Returns the rpm bootstrap macro file name created
2146        in the custom rpm macros path
2147
2148        :return: filename
2149
2150        :rtype: str
2151        """
2152        return 'macros.kiwi-bootstrap-config'
2153
2154    @staticmethod
2155    def get_custom_rpm_image_macro_name():
2156        """
2157        Returns the rpm image macro file name created
2158        in the custom rpm macros path
2159
2160        :return: filename
2161
2162        :rtype: str
2163        """
2164        return 'macros.kiwi-image-config'
2165
2166    @staticmethod
2167    def get_default_package_manager() -> str:
2168        """
2169        Returns the default package manager name if none
2170        is configured in the image description
2171
2172        :return: package manager name
2173
2174        :rtype: str
2175        """
2176        return 'dnf4'
2177
2178    @staticmethod
2179    def get_default_packager_tool(package_manager):
2180        """
2181        Provides the packager tool according to the package manager
2182
2183        :param string package_manager: package manger name
2184
2185        :return: packager tool binary name
2186
2187        :rtype: str
2188        """
2189        rpm_based = ['zypper', 'dnf4', 'dnf5', 'microdnf']
2190        deb_based = ['apt']
2191        if package_manager in rpm_based:
2192            return 'rpm'
2193        elif package_manager in deb_based:
2194            return 'dpkg'
2195        elif package_manager == 'pacman':
2196            return 'pacman'
2197
2198    @staticmethod
2199    def get_discoverable_partition_ids() -> Dict[str, str]:
2200        """
2201        Provides arch specific partition UUIDs as defined
2202        by the UAPI group
2203
2204        :return: partition UUIDs
2205
2206        :rtype: dict
2207        """
2208        arch = Defaults.get_platform_name()
2209        part_uuids_archs = {
2210            'x86_64': {
2211                'root':
2212                    '4f68bce3e8cd4db196e7fbcaf984b709',
2213                'usr':
2214                    '8484680c952148c69c11b0720656f69e',
2215                'usr-verity':
2216                    '77ff5f63e7b64633acf41565b864c0e6'
2217            },
2218            'ix86': {
2219                'root':
2220                    '44479540f29741b29af7d131d5f0458a',
2221                'usr':
2222                    '75250d768cc6458ebd66bd47cc81a812',
2223                'usr-verity':
2224                    '8f461b0d14ee4e819aa9049b6fb97abd'
2225            },
2226            'aarch64': {
2227                'root':
2228                    'b921b0451df041c3af444c6f280d3fae',
2229                'usr':
2230                    'b0e01050ee5f4390949a9101b17104e9',
2231                'usr-verity':
2232                    '6e11a4e7fbca4dedb9e9e1a512bb664e'
2233            },
2234            'riscv64': {
2235                'root':
2236                    '72ec70a6cf7440e6bd494bda08e8f224',
2237                'usr':
2238                    'beaec34b8442439ba40b984381ed097d',
2239                'usr-verity':
2240                    '8f1056be9b0547c481d6be53128e5b54'
2241            }
2242        }
2243        part_uuids_arch = part_uuids_archs.get(arch) or {}
2244        return {
2245            'root':
2246                part_uuids_arch.get('root') or '',
2247            'usr':
2248                part_uuids_arch.get('usr') or '',
2249            'usr-verity':
2250                part_uuids_arch.get('usr-verity') or '',
2251            'usr-secondary':
2252                '75250d768cc6458ebd66bd47cc81a812',
2253            'usr-secondary-verity':
2254                '8f461b0d14ee4e819aa9049b6fb97abd',
2255            'esp':
2256                'c12a7328f81f11d2ba4b00a0c93ec93b',
2257            'xbootldr':
2258                'bc13c2ff59e64262a352b275fd6f7172',
2259            'swap':
2260                '0657fd6da4ab43c484e50933c84b4f4f',
2261            'home':
2262                '933ac7e12eb44f13b8440e14e2aef915',
2263            'srv':
2264                '3b8f842520e04f3b907f1a25a76f98e8',
2265            'var':
2266                '4d21b016b53445c2a9fb5c16e091fd2d',
2267            'tmp':
2268                '7ec6f5573bc54acab29316ef5df639d1',
2269            'user-home':
2270                '773f91ef66d449b5bd83d683bf40ad16',
2271            'linux-generic':
2272                '0fc63daf848347728e793d69d8477de4'
2273        }
2274
2275    @staticmethod
2276    def get_bls_loader_entries_dir() -> str:
2277        """
2278        Provide default loader entries directory for BLS loaders
2279
2280        :return: directory name
2281
2282        :rtype: str
2283        """
2284        return '/boot/loader/entries'
2285
2286    @staticmethod
2287    def get_apk_repo_config() -> str:
2288        """
2289        Repository file for apk
2290
2291        :return: file path name
2292
2293        :rtype: str
2294        """
2295        return '/etc/apk/repositories'
2296
2297    @staticmethod
2298    def get_ca_update_map(target_distribution) -> Optional[Dict[str, str]]:
2299        return CA_UPDATE_MAP.get(target_distribution)
2300
2301    @staticmethod
2302    def get_ca_target_distributions() -> List[str]:
2303        return sorted(CA_UPDATE_MAP.keys())
2304
2305    def get(self, key):
2306        """
2307        Implements get method for profile elements
2308
2309        :param string key: profile keyname
2310
2311        :return: key value
2312
2313        :rtype: str
2314        """
2315        if key in self.defaults:
2316            return self.defaults[key]
2317
2318    @staticmethod
2319    def get_profile_file(root_dir):
2320        """
2321        Return name of profile file for given root directory
2322        """
2323        return root_dir + '/.profile'
2324
2325    def to_profile(self, profile):
2326        """
2327        Implements method to add list of profile keys and their values
2328        to the specified instance of a Profile class
2329
2330        :param object profile: Profile instance
2331        """
2332        for key in sorted(self.profile_key_list):
2333            # Do not apply default values to any variable that was
2334            # already defined in the profile instance.
2335            cur_profile = profile.dot_profile
2336            if key not in cur_profile or cur_profile[key] is None:
2337                profile.add(key, self.get(key))