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_directories(root_path: str) -> List[str]:
1341        """
1342        Provides list of shim vendor directories
1343
1344        Searches distribution specific locations to find shim.efi
1345        below the given root path and return the directory names
1346        to the file found
1347
1348        :param string root_path: image root path
1349
1350        :return: list of directory names or empty list
1351
1352        :rtype: list
1353        """
1354        shim_vendor_patterns = [
1355            '/boot/efi/EFI/*/shim*.efi',
1356            '/EFI/*/shim*.efi'
1357        ]
1358        vendor_paths = []
1359        for shim_vendor_pattern in shim_vendor_patterns:
1360            for shim_file in glob.iglob(root_path + shim_vendor_pattern):
1361                shim_path = os.path.dirname(shim_file)
1362                if shim_path not in vendor_paths:
1363                    vendor_paths.append(shim_path)
1364        return vendor_paths
1365
1366    @staticmethod
1367    def get_default_volume_group_name():
1368        """
1369        Provides default LVM volume group name
1370
1371        :return: name
1372
1373        :rtype: str
1374        """
1375        return 'systemVG'
1376
1377    @staticmethod
1378    def get_min_partition_mbytes():
1379        """
1380        Provides default minimum partition size in mbytes
1381
1382        :return: mbsize value
1383
1384        :rtype: int
1385        """
1386        return 10
1387
1388    @staticmethod
1389    def get_min_volume_mbytes(filesystem: str):
1390        """
1391        Provides default minimum LVM volume size in mbytes
1392        per filesystem
1393
1394        :return: mbsize value
1395
1396        :rtype: int
1397        """
1398        if filesystem == 'btrfs':
1399            return 120
1400        elif filesystem == 'xfs':
1401            return 300
1402        else:
1403            return 30
1404
1405    @staticmethod
1406    def get_lvm_overhead_mbytes():
1407        """
1408        Provides empiric LVM overhead size in mbytes
1409
1410        :return: mbsize value
1411
1412        :rtype: int
1413        """
1414        return 80
1415
1416    @staticmethod
1417    def get_default_boot_mbytes():
1418        """
1419        Provides default boot partition size in mbytes
1420
1421        :return: mbsize value
1422
1423        :rtype: int
1424        """
1425        return 300
1426
1427    @staticmethod
1428    def get_default_efi_boot_mbytes():
1429        """
1430        Provides default EFI partition size in mbytes
1431
1432        :return: mbsize value
1433
1434        :rtype: int
1435        """
1436        return 20
1437
1438    @staticmethod
1439    def get_recovery_spare_mbytes():
1440        """
1441        Provides spare size of recovery partition in mbytes
1442
1443        :return: mbsize value
1444
1445        :rtype: int
1446        """
1447        return 300
1448
1449    @staticmethod
1450    def get_default_legacy_bios_mbytes():
1451        """
1452        Provides default size of bios_grub partition in mbytes
1453
1454        :return: mbsize value
1455
1456        :rtype: int
1457        """
1458        return 2
1459
1460    @staticmethod
1461    def get_default_prep_mbytes():
1462        """
1463        Provides default size of prep partition in mbytes
1464
1465        :return: mbsize value
1466
1467        :rtype: int
1468        """
1469        return 8
1470
1471    @staticmethod
1472    def get_disk_format_types():
1473        """
1474        Provides supported disk format types
1475
1476        :return: disk types
1477
1478        :rtype: list
1479        """
1480        return [
1481            'gce',
1482            'qcow2',
1483            'vmdk',
1484            'ova',
1485            'meta',
1486            'vmx',
1487            'vhd',
1488            'vhdx',
1489            'vhdfixed',
1490            'vdi',
1491            'vagrant.libvirt.box',
1492            'vagrant.virtualbox.box',
1493            'oci'
1494        ]
1495
1496    @staticmethod
1497    def get_vagrant_config_virtualbox_guest_additions():
1498        """
1499        Provides the default value for
1500        ``vagrantconfig.virtualbox_guest_additions_present``
1501
1502        :return: whether guest additions are expected to be present in the
1503            vagrant box
1504
1505        :rtype: bool
1506        """
1507        return False
1508
1509    @staticmethod
1510    def get_firmware_types():
1511        """
1512        Provides supported architecture specific firmware types
1513
1514        :return: firmware types per architecture
1515
1516        :rtype: dict
1517        """
1518        return {
1519            'x86_64': ['efi', 'uefi', 'bios', 'ec2'],
1520            'i586': ['bios'],
1521            'i686': ['bios'],
1522            'ix86': ['bios'],
1523            'aarch64': ['efi', 'uefi'],
1524            'arm64': ['efi', 'uefi'],
1525            'armv5el': ['efi', 'uefi'],
1526            'armv5tel': ['efi', 'uefi'],
1527            'armv6hl': ['efi', 'uefi'],
1528            'armv6l': ['efi', 'uefi'],
1529            'armv7hl': ['efi', 'uefi'],
1530            'armv7l': ['efi', 'uefi'],
1531            'armv8l': ['efi', 'uefi'],
1532            'loongarch64': ['efi', 'uefi'],
1533            'ppc': ['ofw'],
1534            'ppc64': ['ofw', 'opal'],
1535            'ppc64le': ['ofw', 'opal'],
1536            'riscv64': ['efi', 'uefi'],
1537            's390': [],
1538            's390x': []
1539        }
1540
1541    @staticmethod
1542    def get_default_firmware(arch):
1543        """
1544        Provides default firmware for specified architecture
1545
1546        :param string arch: machine architecture name
1547
1548        :return: firmware name
1549
1550        :rtype: str
1551        """
1552        default_firmware = {
1553            'x86_64': 'bios',
1554            'i586': 'bios',
1555            'i686': 'bios',
1556            'ix86': 'bios',
1557            'loongarch64': 'efi',
1558            'ppc': 'ofw',
1559            'ppc64': 'ofw',
1560            'ppc64le': 'ofw',
1561            'arm64': 'efi',
1562            'aarch64': 'efi',
1563            'armv5el': 'efi',
1564            'armv5tel': 'efi',
1565            'armv6hl': 'efi',
1566            'armv6l': 'efi',
1567            'armv7hl': 'efi',
1568            'armv7l': 'efi',
1569            'armv8l': 'efi',
1570            'riscv64': 'efi'
1571        }
1572        if arch in default_firmware:
1573            return default_firmware[arch]
1574
1575    @staticmethod
1576    def get_efi_capable_firmware_names():
1577        """
1578        Provides list of EFI capable firmware names. These are
1579        those for which kiwi supports the creation of an EFI
1580        bootable disk image
1581
1582        :return: firmware names
1583
1584        :rtype: list
1585        """
1586        return ['efi', 'uefi']
1587
1588    @staticmethod
1589    def get_ec2_capable_firmware_names():
1590        """
1591        Provides list of EC2 capable firmware names. These are
1592        those for which kiwi supports the creation of disk images
1593        bootable within the Amazon EC2 public cloud
1594
1595        :return: firmware names
1596
1597        :rtype: list
1598        """
1599        return ['ec2']
1600
1601    @staticmethod
1602    def get_efi_module_directory_name(arch):
1603        """
1604        Provides architecture specific EFI directory name which
1605        stores the EFI binaries for the desired architecture.
1606
1607        :param string arch: machine architecture name
1608
1609        :return: directory name
1610
1611        :rtype: str
1612        """
1613        default_module_directory_names = {
1614            'x86_64': 'x86_64-efi',
1615            'i386': 'i386-efi',
1616
1617            # There is no dedicated xen architecture but there are
1618            # modules provided for xen. Thus we treat it as an
1619            # architecture
1620            'x86_64_xen': 'x86_64-xen',
1621
1622            'aarch64': 'arm64-efi',
1623            'arm64': 'arm64-efi',
1624            'armv5el': 'arm-efi',
1625            'armv5tel': 'arm-efi',
1626            'armv6l': 'arm-efi',
1627            'armv7l': 'arm-efi',
1628            'armv8l': 'arm-efi',
1629            'loongarch64': 'loongarch64-efi',
1630            'riscv64': 'riscv64-efi'
1631        }
1632        if arch in default_module_directory_names:
1633            return default_module_directory_names[arch]
1634
1635    @staticmethod
1636    def get_grub_platform_module_directory_name():
1637        """
1638        Provides grub platform specific directory name which
1639        stores the grub module binaries
1640
1641        :return: directory name
1642
1643        :rtype: str
1644        """
1645        return 'powerpc-ieee1275' if Defaults.is_ppc64_arch(
1646            Defaults.get_platform_name()
1647        ) else 'i386-pc'
1648
1649    @staticmethod
1650    def get_efi_image_name(arch):
1651        """
1652        Provides architecture specific EFI boot binary name
1653
1654        :param string arch: machine architecture name
1655
1656        :return: name
1657
1658        :rtype: str
1659        """
1660        default_efi_image_names = {
1661            'x86_64': 'bootx64.efi',
1662            'i386': 'bootia32.efi',
1663            'aarch64': 'bootaa64.efi',
1664            'arm64': 'bootaa64.efi',
1665            'armv5el': 'bootarm.efi',
1666            'armv5tel': 'bootarm.efi',
1667            'armv6l': 'bootarm.efi',
1668            'armv7l': 'bootarm.efi',
1669            'armv8l': 'bootarm.efi',
1670            'loongarch64': 'bootloongarch64.efi',
1671            'riscv64': 'bootriscv64.efi'
1672        }
1673        if arch in default_efi_image_names:
1674            return default_efi_image_names[arch]
1675
1676    @staticmethod
1677    def get_grub_platform_image_name():
1678        """
1679        Provides platform specific core boot binary name
1680
1681        :return: name
1682
1683        :rtype: str
1684        """
1685        return 'grub.elf' if Defaults.is_ppc64_arch(
1686            Defaults.get_platform_name()
1687        ) else 'core.img'
1688
1689    @staticmethod
1690    def get_default_boot_timeout_seconds():
1691        """
1692        Provides default boot timeout in seconds
1693
1694        :return: seconds
1695
1696        :rtype: int
1697        """
1698        return 10
1699
1700    @staticmethod
1701    def get_default_disk_start_sector():
1702        """
1703        Provides the default initial disk sector for the first disk
1704        partition.
1705
1706        :return: sector value
1707
1708        :rtype: int
1709        """
1710        return Defaults().defaults['kiwi_startsector']
1711
1712    @staticmethod
1713    def get_default_efi_partition_table_type():
1714        """
1715        Provides the default partition table type for efi firmwares.
1716
1717        :return: partition table type name
1718
1719        :rtype: str
1720        """
1721        return 'gpt'
1722
1723    @staticmethod
1724    def get_default_inode_size():
1725        """
1726        Provides default size of inodes in bytes. This is only
1727        relevant for inode based filesystems
1728
1729        :return: bytesize value
1730
1731        :rtype: int
1732        """
1733        return Defaults().defaults['kiwi_inode_size']
1734
1735    @staticmethod
1736    def get_archive_image_types():
1737        """
1738        Provides list of supported archive image types
1739
1740        :return: archive names
1741
1742        :rtype: list
1743        """
1744        return ['tbz', 'cpio']
1745
1746    @staticmethod
1747    def get_container_image_types():
1748        """
1749        Provides list of supported container image types
1750
1751        :return: container names
1752
1753        :rtype: list
1754        """
1755        return ['docker', 'oci', 'appx', 'wsl']
1756
1757    @staticmethod
1758    def get_filesystem_image_types():
1759        """
1760        Provides list of supported filesystem image types
1761
1762        :return: filesystem names
1763
1764        :rtype: list
1765        """
1766        return [
1767            'ext2', 'ext3', 'ext4', 'btrfs', 'squashfs',
1768            'xfs', 'fat16', 'fat32', 'erofs'
1769        ]
1770
1771    @staticmethod
1772    def get_default_live_iso_type():
1773        """
1774        Provides default live iso union type
1775
1776        :return: live iso type
1777
1778        :rtype: str
1779        """
1780        return 'overlay'
1781
1782    @staticmethod
1783    def get_default_uri_type():
1784        """
1785        Provides default URI type
1786
1787        Absolute path specifications used in the context of an URI
1788        will apply the specified default mime type
1789
1790        :return: URI mime type
1791
1792        :rtype: str
1793        """
1794        return 'dir:/'
1795
1796    @staticmethod
1797    def get_dracut_conf_name():
1798        """
1799        Provides file path of dracut config file to be used with KIWI
1800
1801        :return: file path name
1802
1803        :rtype: str
1804        """
1805        return '/etc/dracut.conf.d/02-kiwi.conf'
1806
1807    @staticmethod
1808    def get_live_dracut_modules_from_flag(flag_name):
1809        """
1810        Provides flag_name to dracut modules name map
1811
1812        Depending on the value of the flag attribute in the KIWI image
1813        description specific dracut modules need to be selected
1814
1815        :return: dracut module names as list
1816
1817        :rtype: list
1818        """
1819        live_modules = {
1820            'overlay': ['kiwi-live'],
1821            'dmsquash': ['dmsquash-live', 'livenet']
1822        }
1823        if flag_name in live_modules:
1824            return live_modules[flag_name]
1825        else:
1826            return ['kiwi-live']
1827
1828    @staticmethod
1829    def get_default_live_iso_root_filesystem():
1830        """
1831        Provides default live iso root filesystem type
1832
1833        :return: filesystem name
1834
1835        :rtype: str
1836        """
1837        return 'ext4'
1838
1839    @staticmethod
1840    def get_live_iso_persistent_boot_options(persistent_filesystem=None):
1841        """
1842        Provides list of boot options passed to the dracut
1843        kiwi-live module to setup persistent writing
1844
1845        :return: list of boot options
1846
1847        :rtype: list
1848        """
1849        live_iso_persistent_boot_options = [
1850            'rd.live.overlay.persistent'
1851        ]
1852        if persistent_filesystem:
1853            live_iso_persistent_boot_options.append(
1854                'rd.live.overlay.cowfs={0}'.format(persistent_filesystem)
1855            )
1856        return live_iso_persistent_boot_options
1857
1858    @staticmethod
1859    def get_disk_image_types():
1860        """
1861        Provides supported disk image types
1862
1863        :return: disk image type names
1864
1865        :rtype: list
1866        """
1867        return ['oem']
1868
1869    @staticmethod
1870    def get_live_image_types():
1871        """
1872        Provides supported live image types
1873
1874        :return: live image type names
1875
1876        :rtype: list
1877        """
1878        return ['iso']
1879
1880    @staticmethod
1881    def get_kis_image_types():
1882        """
1883        Provides supported kis image types
1884
1885        :return: kis image type names
1886
1887        :rtype: list
1888        """
1889        return ['kis', 'pxe']
1890
1891    @staticmethod
1892    def get_enclaves_image_types():
1893        """
1894        Provides supported enclave(initrd-only) image types
1895
1896        :return: enclave image type names
1897
1898        :rtype: list
1899        """
1900        return ['enclave']
1901
1902    @staticmethod
1903    def get_boot_image_description_path():
1904        """
1905        Provides the path to find custom kiwi boot descriptions
1906
1907        :return: directory path
1908
1909        :rtype: str
1910        """
1911        return '/usr/share/kiwi/custom_boot'
1912
1913    @staticmethod
1914    def get_boot_image_strip_file():
1915        """
1916        Provides the file path to bootloader strip metadata.
1917        This file contains information about the files and directories
1918        automatically striped out from the kiwi initrd
1919
1920        :return: file path
1921
1922        :rtype: str
1923        """
1924        return Defaults.project_file('config/strip.xml')
1925
1926    @staticmethod
1927    def get_schema_file():
1928        """
1929        Provides file path to kiwi RelaxNG schema
1930
1931        :return: file path
1932
1933        :rtype: str
1934        """
1935        return Defaults.project_file('schema/kiwi.rng')
1936
1937    @staticmethod
1938    def get_common_functions_file():
1939        """
1940        Provides the file path to config functions metadata.
1941
1942        This file contains bash functions used for system
1943        configuration or in the boot code from the kiwi initrd
1944
1945        :return: file path
1946
1947        :rtype: str
1948        """
1949        return Defaults.project_file('config/functions.sh')
1950
1951    @staticmethod
1952    def get_xsl_stylesheet_file():
1953        """
1954        Provides the file path to the KIWI XSLT style sheets
1955
1956        :return: file path
1957
1958        :rtype: str
1959        """
1960        return Defaults.project_file('xsl/master.xsl')
1961
1962    @staticmethod
1963    def get_schematron_module_name():
1964        """
1965        Provides module name for XML SchemaTron validations
1966
1967        :return: python module name
1968
1969        :rtype: str
1970        """
1971        return 'lxml.isoschematron'
1972
1973    @staticmethod
1974    def project_file(filename):
1975        """
1976        Provides the python module base directory search path
1977
1978        The method uses the importlib.resources.path method to identify
1979        files and directories from the application
1980
1981        :param string filename: relative project file
1982
1983        :return: absolute file path name
1984
1985        :rtype: str
1986        """
1987        with as_file(importlib.resources.files('kiwi')) as path:
1988            return f'{path}/{filename}'
1989
1990    @staticmethod
1991    def get_imported_root_image(root_dir):
1992        """
1993        Provides the path to an imported root system image
1994
1995        If the image description specified a derived_from attribute
1996        the file from this attribute is copied into the root_dir
1997        using the name as provided by this method
1998
1999        :param string root_dir: image root directory
2000
2001        :return: file path name
2002
2003        :rtype: str
2004        """
2005        return os.sep.join([root_dir, 'image', 'imported_root'])
2006
2007    @staticmethod
2008    def get_iso_boot_path():
2009        """
2010        Provides arch specific relative path to boot files
2011        on kiwi iso filesystems
2012
2013        :return: relative path name
2014
2015        :rtype: str
2016        """
2017        return os.sep.join(
2018            ['boot', Defaults.get_platform_name()]
2019        )
2020
2021    @staticmethod
2022    def get_iso_tool_category():
2023        """
2024        Provides default iso tool category
2025
2026        :return: name
2027
2028        :rtype: str
2029        """
2030        return 'xorriso'
2031
2032    @staticmethod
2033    def get_iso_media_tag_tool():
2034        """
2035        Provides default iso media tag tool
2036
2037        :return: name
2038
2039        :rtype: str
2040        """
2041        return 'checkmedia'
2042
2043    @staticmethod
2044    def get_container_compression():
2045        """
2046        Provides default container compression
2047
2048        :return: True
2049
2050        :rtype: bool
2051        """
2052        return True
2053
2054    @staticmethod
2055    def get_default_container_name():
2056        """
2057        Provides the default container name.
2058
2059        :return: name
2060
2061        :rtype: str
2062        """
2063        return 'kiwi-container'
2064
2065    @staticmethod
2066    def get_container_base_image_tag():
2067        """
2068        Provides the tag used to identify base layers during the build
2069        of derived images.
2070
2071        :return: tag
2072
2073        :rtype: str
2074        """
2075        return 'base_layer'
2076
2077    @staticmethod
2078    def get_oci_archive_tool():
2079        """
2080        Provides the default OCI archive tool name.
2081
2082        :return: name
2083
2084        :rtype: str
2085        """
2086        return 'umoci'
2087
2088    @staticmethod
2089    def get_part_mapper_tool():
2090        """
2091        Provides the default partition mapper tool name.
2092
2093        :return: name
2094
2095        :rtype: str
2096        """
2097        host_architecture = Defaults.get_platform_name()
2098        if 's390' in host_architecture:
2099            return 'kpartx'
2100        return 'partx'
2101
2102    @staticmethod
2103    def get_default_container_tag():
2104        """
2105        Provides the default container tag.
2106
2107        :return: tag
2108
2109        :rtype: str
2110        """
2111        return 'latest'
2112
2113    @staticmethod
2114    def get_default_container_subcommand():
2115        """
2116        Provides the default container subcommand.
2117
2118        :return: command as a list of arguments
2119
2120        :rtype: list
2121        """
2122        return ['/bin/bash']
2123
2124    @staticmethod
2125    def get_default_container_created_by():
2126        """
2127        Provides the default 'created by' history entry for containers.
2128
2129        :return: the specific kiwi version used for the build
2130
2131        :rtype: str
2132        """
2133        return 'KIWI {0}'.format(__version__)
2134
2135    @staticmethod
2136    def get_custom_rpm_macros_path():
2137        """
2138        Returns the custom macros directory for the rpm database.
2139
2140        :return: path name
2141
2142        :rtype: str
2143        """
2144        return 'usr/lib/rpm/macros.d'
2145
2146    @staticmethod
2147    def get_custom_rpm_bootstrap_macro_name():
2148        """
2149        Returns the rpm bootstrap macro file name created
2150        in the custom rpm macros path
2151
2152        :return: filename
2153
2154        :rtype: str
2155        """
2156        return 'macros.kiwi-bootstrap-config'
2157
2158    @staticmethod
2159    def get_custom_rpm_image_macro_name():
2160        """
2161        Returns the rpm image macro file name created
2162        in the custom rpm macros path
2163
2164        :return: filename
2165
2166        :rtype: str
2167        """
2168        return 'macros.kiwi-image-config'
2169
2170    @staticmethod
2171    def get_default_package_manager() -> str:
2172        """
2173        Returns the default package manager name if none
2174        is configured in the image description
2175
2176        :return: package manager name
2177
2178        :rtype: str
2179        """
2180        return 'dnf4'
2181
2182    @staticmethod
2183    def get_default_packager_tool(package_manager):
2184        """
2185        Provides the packager tool according to the package manager
2186
2187        :param string package_manager: package manger name
2188
2189        :return: packager tool binary name
2190
2191        :rtype: str
2192        """
2193        rpm_based = ['zypper', 'dnf4', 'dnf5', 'microdnf']
2194        deb_based = ['apt']
2195        if package_manager in rpm_based:
2196            return 'rpm'
2197        elif package_manager in deb_based:
2198            return 'dpkg'
2199        elif package_manager == 'pacman':
2200            return 'pacman'
2201
2202    @staticmethod
2203    def get_discoverable_partition_ids() -> Dict[str, str]:
2204        """
2205        Provides arch specific partition UUIDs as defined
2206        by the UAPI group
2207
2208        :return: partition UUIDs
2209
2210        :rtype: dict
2211        """
2212        arch = Defaults.get_platform_name()
2213        part_uuids_archs = {
2214            'x86_64': {
2215                'root':
2216                    '4f68bce3e8cd4db196e7fbcaf984b709',
2217                'usr':
2218                    '8484680c952148c69c11b0720656f69e',
2219                'usr-verity':
2220                    '77ff5f63e7b64633acf41565b864c0e6'
2221            },
2222            'ix86': {
2223                'root':
2224                    '44479540f29741b29af7d131d5f0458a',
2225                'usr':
2226                    '75250d768cc6458ebd66bd47cc81a812',
2227                'usr-verity':
2228                    '8f461b0d14ee4e819aa9049b6fb97abd'
2229            },
2230            'aarch64': {
2231                'root':
2232                    'b921b0451df041c3af444c6f280d3fae',
2233                'usr':
2234                    'b0e01050ee5f4390949a9101b17104e9',
2235                'usr-verity':
2236                    '6e11a4e7fbca4dedb9e9e1a512bb664e'
2237            },
2238            'riscv64': {
2239                'root':
2240                    '72ec70a6cf7440e6bd494bda08e8f224',
2241                'usr':
2242                    'beaec34b8442439ba40b984381ed097d',
2243                'usr-verity':
2244                    '8f1056be9b0547c481d6be53128e5b54'
2245            }
2246        }
2247        part_uuids_arch = part_uuids_archs.get(arch) or {}
2248        return {
2249            'root':
2250                part_uuids_arch.get('root') or '',
2251            'usr':
2252                part_uuids_arch.get('usr') or '',
2253            'usr-verity':
2254                part_uuids_arch.get('usr-verity') or '',
2255            'usr-secondary':
2256                '75250d768cc6458ebd66bd47cc81a812',
2257            'usr-secondary-verity':
2258                '8f461b0d14ee4e819aa9049b6fb97abd',
2259            'esp':
2260                'c12a7328f81f11d2ba4b00a0c93ec93b',
2261            'xbootldr':
2262                'bc13c2ff59e64262a352b275fd6f7172',
2263            'swap':
2264                '0657fd6da4ab43c484e50933c84b4f4f',
2265            'home':
2266                '933ac7e12eb44f13b8440e14e2aef915',
2267            'srv':
2268                '3b8f842520e04f3b907f1a25a76f98e8',
2269            'var':
2270                '4d21b016b53445c2a9fb5c16e091fd2d',
2271            'tmp':
2272                '7ec6f5573bc54acab29316ef5df639d1',
2273            'user-home':
2274                '773f91ef66d449b5bd83d683bf40ad16',
2275            'linux-generic':
2276                '0fc63daf848347728e793d69d8477de4'
2277        }
2278
2279    @staticmethod
2280    def get_bls_loader_entries_dir() -> str:
2281        """
2282        Provide default loader entries directory for BLS loaders
2283
2284        :return: directory name
2285
2286        :rtype: str
2287        """
2288        return '/boot/loader/entries'
2289
2290    @staticmethod
2291    def get_apk_repo_config() -> str:
2292        """
2293        Repository file for apk
2294
2295        :return: file path name
2296
2297        :rtype: str
2298        """
2299        return '/etc/apk/repositories'
2300
2301    @staticmethod
2302    def get_ca_update_map(target_distribution) -> Optional[Dict[str, str]]:
2303        return CA_UPDATE_MAP.get(target_distribution)
2304
2305    @staticmethod
2306    def get_ca_target_distributions() -> List[str]:
2307        return sorted(CA_UPDATE_MAP.keys())
2308
2309    def get(self, key):
2310        """
2311        Implements get method for profile elements
2312
2313        :param string key: profile keyname
2314
2315        :return: key value
2316
2317        :rtype: str
2318        """
2319        if key in self.defaults:
2320            return self.defaults[key]
2321
2322    @staticmethod
2323    def get_profile_file(root_dir):
2324        """
2325        Return name of profile file for given root directory
2326        """
2327        return root_dir + '/.profile'
2328
2329    def to_profile(self, profile):
2330        """
2331        Implements method to add list of profile keys and their values
2332        to the specified instance of a Profile class
2333
2334        :param object profile: Profile instance
2335        """
2336        for key in sorted(self.profile_key_list):
2337            # Do not apply default values to any variable that was
2338            # already defined in the profile instance.
2339            cur_profile = profile.dot_profile
2340            if key not in cur_profile or cur_profile[key] is None:
2341                profile.add(key, self.get(key))