Source code for kiwi.xml_state

# Copyright (c) 2015 SUSE Linux GmbH.  All rights reserved.
#
# This file is part of kiwi.
#
# kiwi is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# kiwi is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with kiwi.  If not, see <http://www.gnu.org/licenses/>
#
import os
from typing import (
    List, Optional, Any, Dict, NamedTuple
)
import re
import logging
import copy
from textwrap import dedent

# project
import kiwi.defaults as defaults

from kiwi import xml_parse
from kiwi.storage.disk import ptable_entry_type
from kiwi.system.uri import Uri
from kiwi.defaults import Defaults
from kiwi.utils.size import StringToSize

from kiwi.exceptions import (
    KiwiProfileNotFound,
    KiwiTypeNotFound,
    KiwiDistributionNameError,
    KiwiFileAccessError
)

log = logging.getLogger('kiwi')

description_type = NamedTuple(
    'description_type', [
        ('author', str),
        ('contact', str),
        ('specification', str)
    ]
)

package_type = NamedTuple(
    'package_type', [
        ('packages_section', xml_parse.packages),
        ('package_section', xml_parse.package)
    ]
)

size_type = NamedTuple(
    'size_type', [
        ('mbytes', int),
        ('additive', str)
    ]
)

volume_type = NamedTuple(
    'volume_type', [
        ('name', str),
        ('parent', str),
        ('size', str),
        ('realpath', str),
        ('mountpoint', Optional[str]),
        ('fullsize', bool),
        ('label', Optional[str]),
        ('attributes', list),
        ('is_root_volume', bool)
    ]
)


[docs] class XMLState: """ **Implements methods to get stateful information from the XML data** :param object xml_data: parse result from XMLDescription.load() :param list profiles: list of used profiles :param object build_type: build <type> section reference """ def __init__( self, xml_data: Any, profiles: List = None, build_type: Any = None ): self.root_partition_uuid: Optional[str] = None self.root_filesystem_uuid: Optional[str] = None self.host_architecture = defaults.PLATFORM_MACHINE self.xml_data = xml_data self.profiles = self._used_profiles(profiles) self.build_type = self._build_type_section( build_type ) self.resolve_this_path()
[docs] def get_preferences_sections(self) -> List: """ All preferences sections for the selected profiles that match the host architecture :return: list of <preferences> section reference(s) :rtype: list """ preferences_list = [] for preferences in self._profiled(self.xml_data.get_preferences()): if self.preferences_matches_host_architecture(preferences): preferences_list.append(preferences) return preferences_list
[docs] def get_description_section(self) -> description_type: """ The description section :return: description_type tuple providing the elements author contact and specification :rtype: tuple """ description = self.xml_data.get_description()[0] return description_type( author=description.get_author()[0], contact=description.get_contact()[0], specification=description.get_specification()[0].strip() )
[docs] def get_users_sections(self) -> List: """ All users sections for the selected profiles :return: list of <users> section reference(s) :rtype: list """ return self._profiled( self.xml_data.get_users() )
[docs] def get_build_type_bundle_format(self) -> str: """ Return bundle_format for build type The bundle_format string is validated against the available name tags from kiwi.system.result::result_name_tags. :return: bundle format string :rtype: str """ return self.build_type.get_bundle_format()
[docs] def get_build_type_name(self) -> str: """ Default build type name :return: Content of image attribute from build type :rtype: str """ return self.build_type.get_image()
[docs] def btrfs_default_volume_requested(self) -> bool: """ Check if setting a default volume for btrfs is requested """ if self.build_type.get_btrfs_set_default_volume() is False: # Setting a default volume is explicitly switched off return False else: # In any other case (True | None) a default volume # is wanted and will be set return True
[docs] def get_image_version(self) -> str: """ Image version from preferences section. Multiple occurences of version in preferences sections are not forbidden, however only the first version found defines the final image version :return: Content of <version> section :rtype: str """ for preferences in self.get_preferences_sections(): version = preferences.get_version() if version: return version[0] return ''
[docs] def get_initrd_system(self) -> str: """ Name of initrd system to use Depending on the image type a specific initrd system is either pre selected or free of choice according to the XML type setup. :return: 'dracut', 'kiwi' or 'none' :rtype: str """ pre_selection_map = { 'vmx': 'dracut', 'oem': 'dracut', 'iso': 'dracut', 'kis': 'dracut', 'pxe': 'kiwi', } build_type = self.get_build_type_name() default_initrd_system = pre_selection_map.get(build_type) or 'none' if build_type == 'iso': # iso type always use dracut as initrd system return default_initrd_system # Allow to choose for any other build type return self.build_type.get_initrd_system() or default_initrd_system
[docs] def get_locale(self) -> Optional[List]: """ Gets list of locale names if configured. Takes the first locale setup from the existing preferences sections into account. :return: List of names or None :rtype: list|None """ for preferences in self.get_preferences_sections(): locale_section = preferences.get_locale() if locale_section: return locale_section[0].split(',') return None
[docs] def get_rpm_locale(self) -> Optional[List]: """ Gets list of locale names to filter out by rpm if rpm-locale-filtering is switched on the the list always contains: [POSIX, C, C.UTF-8] and is extended by the optionaly configured locale :return: List of names or None :rtype: list|None """ if self.get_rpm_locale_filtering(): rpm_locale = ['POSIX', 'C', 'C.UTF-8'] configured_locale = self.get_locale() if configured_locale: for locale in configured_locale: rpm_locale.append(locale) return rpm_locale return None
[docs] def get_rpm_locale_filtering(self) -> bool: """ Gets the rpm-locale-filtering configuration flag. Returns False if not present. :return: True or False :rtype: bool """ for preferences in self.get_preferences_sections(): locale_filtering = preferences.get_rpm_locale_filtering() if locale_filtering: return locale_filtering[0] return False
[docs] def get_rpm_excludedocs(self) -> bool: """ Gets the rpm-excludedocs configuration flag. Returns False if not present. :return: True or False :rtype: bool """ for preferences in self.get_preferences_sections(): exclude_docs = preferences.get_rpm_excludedocs() if exclude_docs: return exclude_docs[0] return False
[docs] def get_rpm_check_signatures(self) -> bool: """ Gets the rpm-check-signatures configuration flag. Returns False if not present. :return: True or False :rtype: bool """ for preferences in self.get_preferences_sections(): check_signatures = preferences.get_rpm_check_signatures() if check_signatures: return check_signatures[0] return False
[docs] def get_package_manager(self) -> str: """ Get configured package manager from selected preferences section :return: Content of the <packagemanager> section :rtype: str """ for preferences in self.get_preferences_sections(): package_manager = preferences.get_packagemanager() if package_manager: return package_manager[0] return Defaults.get_default_package_manager()
[docs] def get_release_version(self) -> str: """ Get configured release version from selected preferences section :return: Content of the <release-version> section or '' :rtype: str """ release_version = '' for preferences in self.get_preferences_sections(): release_version = preferences.get_release_version() if release_version: release_version = release_version[0] break return release_version
[docs] def get_packages_sections(self, section_types: List) -> List: """ List of packages sections matching given section type(s) :param list section_types: type name(s) from packages sections :return: list of <packages> section reference(s) :rtype: list """ result = [] packages_sections = self._profiled( self.xml_data.get_packages() ) for packages in packages_sections: packages_type = packages.get_type() if packages_type in section_types: result.append(packages) return result
[docs] def package_matches_host_architecture(self, package: Any) -> bool: """ Tests if the given package section is applicable for the current host architecture. If no architecture is specified within the section it is considered as a match returning True. Note: The XML section pointer must provide an arch attribute :param section: XML section object :return: True or False :rtype: bool """ return self._section_matches_host_architecture(package)
[docs] def profile_matches_host_architecture(self, profile: Any) -> bool: """ Tests if the given profile section is applicable for the current host architecture. If no architecture is specified within the section it is considered as a match returning True. Note: The XML section pointer must provide an arch attribute :param section: XML section object :return: True or False :rtype: bool """ return self._section_matches_host_architecture(profile)
[docs] def preferences_matches_host_architecture(self, preferences: Any) -> bool: """ Tests if the given preferences section is applicable for the current host architecture. If no architecture is specified within the section it is considered as a match returning True. Note: The XML section pointer must provide an arch attribute :param section: XML section object :return: True or False :rtype: bool """ return self._section_matches_host_architecture(preferences)
[docs] def get_package_sections( self, packages_sections: List ) -> List[package_type]: """ List of package sections from the given packages sections. Each list element contains a tuple with the <package> section reference and the <packages> section this package belongs to If a package entry specfies an architecture, it is only taken if the host architecture matches the configured architecture :param list packages_sections: <packages> :return: Contains list of package_type tuples .. code:: python [package_type(packages_section=object, package_section=object)] :rtype: list """ result = [] if packages_sections: for packages_section in packages_sections: package_list = packages_section.get_package() if package_list: for package in package_list: if self.package_matches_host_architecture(package): result.append( package_type( packages_section=packages_section, package_section=package ) ) return result
[docs] def get_to_become_deleted_packages(self, force: bool = True) -> List: """ List of package names from the type="delete" or type="uninstall" packages section(s) :param bool force: return "delete" type if True, "uninstall" type otherwise :return: package names :rtype: list """ result = [] to_become_deleted_packages_sections = self.get_packages_sections( ['delete' if force else 'uninstall'] ) package_list = self.get_package_sections( to_become_deleted_packages_sections ) if package_list: for package in package_list: result.append(package.package_section.get_name()) return sorted(list(set(result)))
[docs] def get_bootstrap_packages_sections(self) -> List: """ List of packages sections matching type="bootstrap" :return: list of <packages> section reference(s) :rtype: list """ return self.get_packages_sections(['bootstrap'])
[docs] def get_image_packages_sections(self) -> List: """ List of packages sections matching type="image" :return: list of <packages> section reference(s) :rtype: list """ return self.get_packages_sections(['image'])
[docs] def get_bootstrap_packages(self, plus_packages: List = None) -> List: """ List of package names from the type="bootstrap" packages section(s) The list gets the selected package manager appended if there is a request to install packages inside of the image via a chroot operation :param list plus_packages: list of additional packages :return: package names :rtype: list """ result = [] bootstrap_packages_sections = self.get_bootstrap_packages_sections() package_list = self.get_package_sections( bootstrap_packages_sections ) if package_list: for package in package_list: result.append(package.package_section.get_name().strip()) if self.get_system_packages(): package_manager_name = self.get_package_manager() if package_manager_name == 'dnf4': # The package name for dnf4 is just dnf. Thus # the name must be adapted in this case package_manager_name = 'dnf' result.append(package_manager_name) if plus_packages: result += plus_packages return sorted(list(set(result)))
[docs] def get_system_packages(self) -> List: """ List of package names from the packages sections matching type="image" and type=build_type :return: package names :rtype: list """ result = [] image_packages_sections = self.get_packages_sections( ['image', self.get_build_type_name()] ) package_list = self.get_package_sections( image_packages_sections ) if package_list: for package in package_list: result.append(package.package_section.get_name().strip()) return sorted(list(set(result)))
[docs] def get_bootstrap_archives(self) -> List: """ List of archive names from the type="bootstrap" packages section(s) :return: archive names :rtype: list """ result = [] bootstrap_packages_sections = self.get_bootstrap_packages_sections() if bootstrap_packages_sections: for bootstrap_packages_section in bootstrap_packages_sections: archive_list = bootstrap_packages_section.get_archive() if archive_list: for archive in archive_list: result.append(archive.get_name().strip()) return sorted(result)
[docs] def get_system_archives(self) -> List: """ List of archive names from the packages sections matching type="image" and type=build_type :return: archive names :rtype: list """ result = [] image_packages_sections = self.get_packages_sections( ['image', self.get_build_type_name()] ) for packages in image_packages_sections: for archive in packages.get_archive(): result.append(archive.get_name().strip()) return sorted(result)
[docs] def get_ignore_packages(self, section_type: str) -> List: """ List of ignore package names from the packages sections matching section_type and type=build_type :return: package names :rtype: list """ result = [] image_packages_sections = self.get_packages_sections( [section_type, self.get_build_type_name()] ) for packages in image_packages_sections: for package in packages.get_ignore(): if self.package_matches_host_architecture(package): result.append(package.get_name().strip()) return sorted(result)
[docs] def get_system_ignore_packages(self) -> List: """ List of ignore package names from the packages sections matching type="image" and type=build_type :return: package names :rtype: list """ return self.get_ignore_packages('image')
[docs] def get_bootstrap_ignore_packages(self) -> List: """ List of ignore package names from the packages sections matching type="image" and type=build_type :return: package names :rtype: list """ return self.get_ignore_packages('bootstrap')
[docs] def get_bootstrap_package_name(self) -> str: """ bootstrap_package name from type="bootstrap" packages section :return: bootstrap_package name :rtype: str """ typed_packages_sections = self.get_packages_sections( ['bootstrap', self.get_build_type_name()] ) bootstrap_package = '' for packages in typed_packages_sections: bootstrap_package = packages.get_bootstrap_package() if bootstrap_package: break return bootstrap_package
[docs] def get_collection_type(self, section_type: str = 'image') -> str: """ Collection type from packages sections matching given section type. If no collection type is specified the default collection type is set to: onlyRequired :param str section_type: type name from packages section :return: collection type name :rtype: str """ typed_packages_sections = self.get_packages_sections( [section_type, self.get_build_type_name()] ) collection_type = 'onlyRequired' for packages in typed_packages_sections: packages_collection_type = packages.get_patternType() if packages_collection_type: collection_type = packages_collection_type break return collection_type
[docs] def get_bootstrap_collection_type(self) -> str: """ Collection type for packages sections matching type="bootstrap" :return: collection type name :rtype: str """ return self.get_collection_type('bootstrap')
[docs] def get_system_collection_type(self) -> str: """ Collection type for packages sections matching type="image" :return: collection type name :rtype: str """ return self.get_collection_type('image')
[docs] def get_collection_modules(self) -> Dict[str, List[str]]: """ Dict of collection modules to enable and/or disable :return: Dict of the form: .. code:: python { 'enable': [ "module:stream", "module" ], 'disable': [ "module" ] } :rtype: dict """ modules: Dict[str, List[str]] = { 'disable': [], 'enable': [] } for packages in self.get_bootstrap_packages_sections(): for collection_module in packages.get_collectionModule(): module_name = collection_module.get_name() if collection_module.get_enable() is False: modules['disable'].append(module_name) else: stream = collection_module.get_stream() if stream: modules['enable'].append(f'{module_name}:{stream}') else: modules['enable'].append(module_name) return modules
[docs] def get_collections(self, section_type: str = 'image') -> List: """ List of collection names from the packages sections matching type=section_type and type=build_type :return: collection names :rtype: list """ result = [] typed_packages_sections = self.get_packages_sections( [section_type, self.get_build_type_name()] ) for packages in typed_packages_sections: for collection in packages.get_namedCollection(): result.append(collection.get_name()) return list(set(result))
[docs] def get_bootstrap_collections(self) -> List: """ List of collection names from the packages sections matching type="bootstrap" :return: collection names :rtype: list """ return self.get_collections('bootstrap')
[docs] def get_system_collections(self) -> List: """ List of collection names from the packages sections matching type="image" :return: collection names :rtype: list """ return self.get_collections('image')
[docs] def get_products(self, section_type: str = 'image') -> List: """ List of product names from the packages sections matching type=section_type and type=build_type :param str section_type: type name from packages section :return: product names :rtype: list """ result = [] typed_packages_sections = self.get_packages_sections( [section_type, self.get_build_type_name()] ) for packages in typed_packages_sections: for product in packages.get_product(): result.append(product.get_name()) return list(set(result))
[docs] def get_bootstrap_products(self) -> List: """ List of product names from the packages sections matching type="bootstrap" :return: product names :rtype: list """ return self.get_products('bootstrap')
[docs] def get_system_products(self) -> List: """ List of product names from the packages sections matching type="image" :return: product names :rtype: list """ return self.get_products('image')
[docs] def is_xen_server(self) -> bool: """ Check if build type domain setup specifies a Xen Server (dom0) :return: True or False :rtype: bool """ return self.build_type.get_xen_server()
[docs] def is_xen_guest(self) -> bool: """ Check if build type setup specifies a Xen Guest (domX) The check is based on the architecture, the firmware and xen_loader configuration values: * We only support Xen setup on the x86_64 architecture * Firmware pointing to ec2 means the image is targeted to run in Amazon EC2 which is a Xen guest * Machine setup with a xen_loader attribute also indicates a Xen guest target :return: True or False :rtype: bool """ if self.host_architecture != 'x86_64': # We only support Xen stuff on x86_64 return False firmware = self.build_type.get_firmware() machine_section = self.get_build_type_machine_section() if firmware and firmware in Defaults.get_ec2_capable_firmware_names(): # the image is targeted to run in Amazon EC2 which is a Xen system return True elif machine_section and machine_section.get_xen_loader(): # the image provides a machine section with a guest loader setup return True return False
[docs] def get_build_type_partitions_section(self) -> Any: """ First partitions section from the build type section :return: <partitions> section reference :rtype: xml_parse::partitions """ partitions_sections = self.build_type.get_partitions() if partitions_sections: return partitions_sections[0] return None
[docs] def get_build_type_system_disk_section(self) -> Any: """ First system disk section from the build type section :return: <systemdisk> section reference :rtype: xml_parse::systemdisk """ systemdisk_sections = self.build_type.get_systemdisk() if systemdisk_sections: return systemdisk_sections[0] return None
[docs] def get_build_type_machine_section(self) -> Any: """ First machine section from the build type section :return: <machine> section reference :rtype: xml_parse::machine """ machine_sections = self.build_type.get_machine() if machine_sections: return machine_sections[0] return None
[docs] def get_build_type_vagrant_config_section(self) -> Any: """ First vagrantconfig section from the build type section :return: <vagrantconfig> section reference :rtype: xml_parse::vagrantconfig """ vagrant_config_sections = self.build_type.get_vagrantconfig() if vagrant_config_sections: return vagrant_config_sections[0] return None
[docs] def get_vagrant_config_virtualbox_guest_additions(self) -> bool: """ Attribute virtualbox_guest_additions_present from the first vagrantconfig section. :return: True|False :rtype: bool """ vagrant_config_sections = self.get_build_type_vagrant_config_section() if not vagrant_config_sections.virtualbox_guest_additions_present: return Defaults.get_vagrant_config_virtualbox_guest_additions() else: return vagrant_config_sections.virtualbox_guest_additions_present
[docs] def get_build_type_vmdisk_section(self) -> Any: """ First vmdisk section from the first machine section in the build type section :return: <vmdisk> section reference :rtype: xml_parse::vmdisk """ machine_section = self.get_build_type_machine_section() if machine_section: vmdisk_sections = machine_section.get_vmdisk() if vmdisk_sections: return vmdisk_sections[0] return None
[docs] def get_build_type_vmnic_entries(self) -> List: """ vmnic section(s) from the first machine section in the build type section :return: list of <vmnic> section reference(s) :rtype: list """ machine_section = self.get_build_type_machine_section() if machine_section: return machine_section.get_vmnic() else: return []
[docs] def get_build_type_vmdvd_section(self) -> Any: """ First vmdvd section from the first machine section in the build type section :return: <vmdvd> section reference :rtype: xml_parse::vmdvd """ machine_section = self.get_build_type_machine_section() if machine_section: vmdvd_sections = machine_section.get_vmdvd() if vmdvd_sections: return vmdvd_sections[0] return None
[docs] def get_build_type_vmconfig_entries(self) -> List: """ List of vmconfig-entry section values from the first machine section in the build type section :return: <vmconfig_entry> section reference(s) :rtype: list """ machine_section = self.get_build_type_machine_section() if machine_section: vmconfig_entries = machine_section.get_vmconfig_entry() if vmconfig_entries: return vmconfig_entries return []
[docs] def get_build_type_bootloader_section(self) -> Any: """ First bootloader section from the build type section :return: <bootloader> section reference :rtype: xml_parse::bootloader """ bootloader_sections = self.build_type.get_bootloader() if bootloader_sections: return bootloader_sections[0] return None
[docs] def get_build_type_bootloader_name(self) -> str: """ Return bootloader name for selected build type :return: bootloader name :rtype: str """ bootloader = self.get_build_type_bootloader_section() return bootloader.get_name() if bootloader else \ Defaults.get_default_bootloader()
[docs] def get_build_type_bootloader_console(self) -> List[str]: """ Return bootloader console setting for selected build type :return: list of console settings for output (first element) and input (second element) :rtype: list """ result = ['', ''] bootloader = self.get_build_type_bootloader_section() if bootloader: combined_console = bootloader.get_console() if combined_console: console_out, *console_in = combined_console.split(' ')[:2] console_in = console_out if not console_in else console_in[0] result = [ console_out if console_out != 'none' else '', console_in if console_in != 'none' else '' ] return result
[docs] def get_build_type_bootloader_serial_line_setup(self) -> Optional[str]: """ Return bootloader serial line setup parameters for the selected build type :return: serial line setup :rtype: str """ bootloader = self.get_build_type_bootloader_section() if bootloader: return bootloader.get_serial_line() return None
[docs] def get_build_type_bootloader_timeout(self) -> Optional[str]: """ Return bootloader timeout setting for selected build type :return: timeout string :rtype: str """ bootloader = self.get_build_type_bootloader_section() if bootloader: return bootloader.get_timeout() return None
[docs] def get_build_type_bootloader_timeout_style(self) -> Optional[str]: """ Return bootloader timeout style setting for selected build type :return: timeout_style string :rtype: str """ bootloader = self.get_build_type_bootloader_section() if bootloader: return bootloader.get_timeout_style() return None
[docs] def get_build_type_bootloader_targettype(self) -> Optional[str]: """ Return bootloader target type setting. Only relevant for the zipl bootloader because zipl is installed differently depending on the storage target it runs later :return: target type string :rtype: str """ bootloader = self.get_build_type_bootloader_section() if bootloader: return bootloader.get_targettype() return None
[docs] def get_build_type_bootloader_settings_section(self) -> Any: """ First bootloadersettings section from the build type bootloader section :return: <bootloadersettings> section reference :rtype: xml_parse::bootloadersettings """ bootloader_section = self.get_build_type_bootloader_section() bootloader_settings_section = None if bootloader_section: bootloader_settings_section = \ bootloader_section.get_bootloadersettings() return bootloader_settings_section
[docs] def get_bootloader_options(self, option_type: str) -> List[str]: """ List of custom options used in the process to run bootloader setup workloads """ result: List[str] = [] bootloader_settings = self.get_build_type_bootloader_settings_section() if bootloader_settings: options = [] if option_type == 'shim': options = bootloader_settings.get_shimoption() elif option_type == 'install': options = bootloader_settings.get_installoption() elif option_type == 'config': options = bootloader_settings.get_configoption() for option in options: result.append(option.get_name()) if option.get_value(): result.append(option.get_value()) return result
[docs] def get_bootloader_shim_options(self) -> List[str]: """ List of custom options used in the process to setup secure boot """ return self.get_bootloader_options('shim')
[docs] def get_bootloader_install_options(self) -> List[str]: """ List of custom options used in the bootloader installation """ return self.get_bootloader_options('install')
[docs] def get_bootloader_config_options(self) -> List[str]: """ List of custom options used in the bootloader configuration """ return self.get_bootloader_options('config')
[docs] def get_build_type_bootloader_use_disk_password(self) -> bool: """ Indicate whether the bootloader configuration should use the password protecting the encrypted root volume. :return: True|False :rtype: bool """ bootloader = self.get_build_type_bootloader_section() if bootloader: return bootloader.get_use_disk_password() return False
[docs] def get_build_type_oemconfig_section(self) -> Any: """ First oemconfig section from the build type section :return: <oemconfig> section reference :rtype: xml_parse::oemconfig """ oemconfig_sections = self.build_type.get_oemconfig() if oemconfig_sections: return oemconfig_sections[0] return None
[docs] def get_oemconfig_oem_resize(self) -> bool: """ State value to activate/deactivate disk resize. Returns a boolean value if specified or True to set resize on by default :return: Content of <oem-resize> section value :rtype: bool """ oemconfig = self.get_build_type_oemconfig_section() if oemconfig and oemconfig.get_oem_resize(): return oemconfig.get_oem_resize()[0] else: return True
[docs] def get_oemconfig_oem_systemsize(self) -> int: """ State value to retrieve root partition size :return: Content of <oem-systemsize> section value :rtype: int """ oemconfig = self.get_build_type_oemconfig_section() if oemconfig and oemconfig.get_oem_systemsize(): return int(oemconfig.get_oem_systemsize()[0]) else: return 0
[docs] def get_oemconfig_oem_multipath_scan(self) -> bool: """ State value to activate multipath maps. Returns a boolean value if specified or False :return: Content of <oem-multipath-scan> section value :rtype: bool """ oemconfig = self.get_build_type_oemconfig_section() if oemconfig and oemconfig.get_oem_multipath_scan(): return oemconfig.get_oem_multipath_scan()[0] return False
[docs] def get_oemconfig_swap_mbytes(self) -> Optional[int]: """ Return swapsize in MB if requested or None Operates on the value of oem-swap and if set to true returns the given size or the default value. :return: Content of <oem-swapsize> section value or default :rtype: int """ oemconfig = self.get_build_type_oemconfig_section() if oemconfig and oemconfig.get_oem_swap(): swap_requested = oemconfig.get_oem_swap()[0] if swap_requested: swapsize = oemconfig.get_oem_swapsize() if swapsize: return swapsize[0] else: return Defaults.get_swapsize_mbytes() return None
[docs] def get_oemconfig_swap_name(self) -> str: """ Return the swap space name Operates on the value of oem-swapname and if set returns the configured name or the default name: LVSwap The name of the swap space is used only if the image is configured to use the LVM volume manager. In this case swap is a volume and the volume takes a name. In any other case the given name will have no effect. :return: Content of <oem-swapname> section value or default :rtype: str """ oemconfig = self.get_build_type_oemconfig_section() if oemconfig and oemconfig.get_oem_swapname(): return oemconfig.get_oem_swapname()[0] return 'LVSwap'
[docs] def get_build_type_containerconfig_section(self) -> Any: """ First containerconfig section from the build type section :return: <containerconfig> section reference :rtype: xml_parse::containerconfig """ container_config_sections = self.build_type.get_containerconfig() if container_config_sections: return container_config_sections[0] return None
[docs] def get_installmedia_initrd_modules(self, action: str) -> List[str]: """ Gets the list of modules to append in installation initrds :return: a list of dracut module names :rtype: list """ modules: List[str] = [] installmedia = self.build_type.get_installmedia() if not installmedia: return modules initrd_sections = installmedia[0].get_initrd() for initrd_section in initrd_sections: if initrd_section.get_action() == action: for module in initrd_section.get_dracut(): modules.append(module.get_module()) return modules
[docs] def get_build_type_size( self, include_unpartitioned: bool = False ) -> Optional[size_type]: """ Size information from the build type section. If no unit is set the value is treated as mbytes :param bool include_unpartitioned: sets if the unpartitioned area should be included in the computed size or not :return: mbytes :rtype: int """ size_section = self.build_type.get_size() if size_section: unit = size_section[0].get_unit() additive = size_section[0].get_additive() unpartitioned = size_section[0].get_unpartitioned() value = int(size_section[0].get_valueOf_()) if not include_unpartitioned and unpartitioned is not None: value -= unpartitioned if unit == 'G': value *= 1024 return size_type( mbytes=value, additive=additive ) return None
[docs] def get_build_type_unpartitioned_bytes(self) -> int: """ Size of the unpartitioned area for image in megabytes :return: mbytes :rtype: int """ size_section = self.build_type.get_size() if size_section: unit = size_section[0].get_unit() or 'M' unpartitioned = size_section[0].get_unpartitioned() or 0 return StringToSize.to_bytes('{0}{1}'.format(unpartitioned, unit)) return 0
[docs] def get_disk_start_sector(self) -> int: """ First disk sector number to be used by the first disk partition. :return: number :rtype: int """ disk_start_sector = self.build_type.get_disk_start_sector() if disk_start_sector is None: disk_start_sector = Defaults.get_default_disk_start_sector() return disk_start_sector
[docs] def get_build_type_spare_part_size(self) -> Optional[int]: """ Size information for the spare_part size from the build type. If no unit is set the value is treated as mbytes :return: mbytes :rtype: int """ spare_part_size = self.build_type.get_spare_part() if spare_part_size: return self._to_mega_byte(spare_part_size) return None
[docs] def get_build_type_spare_part_fs_attributes(self) -> Optional[List]: """ Build type specific list of filesystem attributes applied to the spare partition. :return: list of strings or empty list :rtype: list """ spare_part_attributes = self.build_type.get_spare_part_fs_attributes() if spare_part_attributes: return spare_part_attributes.strip().split(',') return None
[docs] def get_build_type_format_options(self) -> Dict: """ Disk format options returned as a dictionary :return: format options :rtype: dict """ result = {} format_options = self.build_type.get_formatoptions() if format_options: for option in format_options.split(','): key_value_list = option.split('=') if len(key_value_list) == 2: result[key_value_list[0]] = key_value_list[1] else: result[key_value_list[0]] = None return result
[docs] def get_volume_group_name(self) -> str: """ Volume group name from selected <systemdisk> section :return: volume group name :rtype: str """ systemdisk_section = self.get_build_type_system_disk_section() volume_group_name = None if systemdisk_section: volume_group_name = systemdisk_section.get_name() if not volume_group_name: volume_group_name = Defaults.get_default_volume_group_name() return volume_group_name
[docs] def get_users(self) -> List: """ List of configured users. Each entry in the list is a single xml_parse::user instance. :return: list of <user> section reference(s) :rtype: list """ users_list = [] users_names_added = [] for users_section in self.get_users_sections(): for user in users_section.get_user(): if user.get_name() not in users_names_added: users_list.append(user) users_names_added.append(user.get_name()) return users_list
[docs] def get_user_groups(self, user_name) -> List[str]: """ List of group names matching specified user Each entry in the list is the name of a group and optionally its group ID separated by a colon, that the specified user belongs to. The first item in the list is the login or primary group. The list will be empty if no groups are specified in the description file. :return: groups data for the given user :rtype: list """ groups_list = [] for users_section in self.get_users_sections(): for user in users_section.get_user(): if user.get_name() == user_name: user_groups = user.get_groups() if user_groups: groups_list += user.get_groups().split(',') # order of list items matter, thus we don't use set() here # better faster, nicer solutions welcome :) result_group_list = [] for item in groups_list: if item not in result_group_list: result_group_list.append(item) return result_group_list
[docs] def get_container_config(self) -> Dict: """ Dictionary of containerconfig information Takes attributes and subsection data from the selected <containerconfig> section and stores it in a dictionary """ container_config = self._match_docker_base_data() container_config.update( self._match_docker_entrypoint() ) container_config.update( self._match_docker_subcommand() ) container_config.update( self._match_docker_expose_ports() ) container_config.update( self._match_docker_volumes() ) container_config.update( self._match_docker_environment() ) container_config.update( self._match_docker_labels() ) container_config.update( self._match_docker_history() ) desc = self.get_description_section() author_contact = "{0} <{1}>".format(desc.author, desc.contact) if 'history' not in container_config: container_config['history'] = {} if 'author' not in container_config['history']: container_config['history']['author'] = author_contact if 'maintainer' not in container_config: container_config['maintainer'] = author_contact return container_config
[docs] def set_container_config_tag(self, tag: str) -> None: """ Set new tag name in containerconfig section In order to set a new tag value an existing containerconfig and tag setup is required :param str tag: tag name """ container_config_section = self.get_build_type_containerconfig_section() if container_config_section and container_config_section.get_tag(): container_config_section.set_tag(tag) else: message = dedent('''\n No <containerconfig> section and/or tag attribute configured In order to set the tag {0} as new container tag, an initial containerconfig section including a tag setup is required ''') log.warning(message.format(tag))
[docs] def add_container_config_label(self, label_name: str, value: str) -> None: """ Adds a new label in the containerconfig section, if a label with the same name is already defined in containerconfig it gets overwritten by this method. :param str label_name: the string representing the label name :param str value: the value of the label """ if self.get_build_type_name() not in ['docker', 'oci']: message = dedent('''\n Labels can only be configured for container image types docker and oci. ''') log.warning(message) return container_config_section = self.get_build_type_containerconfig_section() if not container_config_section: container_config_section = xml_parse.containerconfig( name=Defaults.get_default_container_name(), tag=Defaults.get_default_container_tag() ) self.build_type.set_containerconfig([container_config_section]) labels = container_config_section.get_labels() if not labels: labels = [xml_parse.labels()] label_names = [] for label in labels[0].get_label(): label_names.append(label.get_name()) if label_name in label_names: labels[0].replace_label_at( label_names.index(label_name), xml_parse.label(label_name, value) ) else: labels[0].add_label(xml_parse.label(label_name, value)) container_config_section.set_labels(labels)
[docs] def get_partitions(self) -> Dict[str, ptable_entry_type]: """ Dictionary of configured partitions. Each entry in the dict references a ptable_entry_type Each key in the dict references the name of the partition entry as handled by KIWI :return: Contains dict of ptable_entry_type tuples .. code:: python { 'NAME': ptable_entry_type( mbsize=int, clone=int, partition_name=str, partition_type=str, mountpoint=str, filesystem=str ) } :rtype: dict """ partitions: Dict[str, ptable_entry_type] = {} partitions_section = self.get_build_type_partitions_section() if not partitions_section: return partitions for partition in partitions_section.get_partition(): name = partition.get_name() partition_name = partition.get_partition_name() or f'p.lx{name}' partitions[name] = ptable_entry_type( mbsize=self._to_mega_byte(partition.get_size()), clone=int(partition.get_clone()) if partition.get_clone() else 0, partition_name=partition_name, partition_type=partition.get_partition_type() or 't.linux', mountpoint=partition.get_mountpoint(), filesystem=partition.get_filesystem() ) return partitions
[docs] def get_volumes(self) -> List[volume_type]: """ List of configured systemdisk volumes. Each entry in the list is a tuple with the following information * name: name of the volume * size: size of the volume * realpath: system path to lookup volume data. If no mountpoint is set the volume name is used as data path. * mountpoint: volume mount point and volume data path * fullsize: takes all space True|False * attributes: list of volume attributes handled via chattr :return: Contains list of volume_type tuples .. code:: python [ volume_type( name=volume_name, parent=volume_parent, size=volume_size, realpath=path, mountpoint=path, fullsize=True, label=volume_label, attributes=['no-copy-on-write'], is_root_volume=True|False ) ] :rtype: list """ volume_type_list: List[volume_type] = [] systemdisk_section = self.get_build_type_system_disk_section() swap_mbytes = self.get_oemconfig_swap_mbytes() swap_name = self.get_oemconfig_swap_name() if not systemdisk_section: return volume_type_list volumes = systemdisk_section.get_volume() have_root_volume_setup = False have_full_size_volume = False if volumes: for volume in volumes: # volume setup for a full qualified volume with name and # mountpoint information. See below for exceptions name = volume.get_name() parent = volume.get_parent() or '' mountpoint = volume.get_mountpoint() realpath = mountpoint size = volume.get_size() freespace = volume.get_freespace() fullsize = False label = volume.get_label() attributes = [] is_root_volume = False if volume.get_copy_on_write() is False: # by default copy-on-write is switched on for any # filesystem. Thus only if no copy on write is requested # the attribute is handled attributes.append('no-copy-on-write') if volume.get_filesystem_check() is True: # by default filesystem check is switched off for any # filesystem except the rootfs. Thus only if filesystem # check is requested the attribute is handled attributes.append('enable-for-filesystem-check') if '@root' in name: # setup root volume, it takes an optional volume # name if specified as @root=name and has no specific # mountpoint. The default name is set to # defaults.ROOT_VOLUME_NAME if no other root volume # name is provided mountpoint = None realpath = '/' is_root_volume = True root_volume_expression = re.match( r'@root=(.+)', name ) if root_volume_expression: name = root_volume_expression.group(1) else: name = defaults.ROOT_VOLUME_NAME have_root_volume_setup = True elif not mountpoint: # setup volume without mountpoint. In this case the name # attribute is used as mountpoint path and a name for the # volume is created from that path information mountpoint = name realpath = mountpoint name = self._to_volume_name(name) if size: size = 'size:' + format( self._to_mega_byte(size) ) elif freespace: size = 'freespace:' + format( self._to_mega_byte(freespace) ) else: size = 'freespace:' + format( Defaults.get_min_volume_mbytes() ) if ':all' in size: size = None fullsize = True have_full_size_volume = True volume_type_list.append( volume_type( name=name, parent=parent, size=size, fullsize=fullsize, mountpoint=mountpoint, realpath=realpath, label=label, attributes=attributes, is_root_volume=is_root_volume ) ) if not have_root_volume_setup: # There must always be a root volume setup. It will be the # full size volume if no other volume has this setup volume_management = self.get_volume_management() root_volume_name = \ defaults.ROOT_VOLUME_NAME if volume_management == 'lvm' else '' if have_full_size_volume: size = 'freespace:' + format( Defaults.get_min_volume_mbytes() ) fullsize = False else: size = None fullsize = True volume_type_list.append( volume_type( name=root_volume_name, parent='', size=size, fullsize=fullsize, mountpoint=None, realpath='/', label=None, attributes=[], is_root_volume=True ) ) if swap_mbytes and self.get_volume_management() == 'lvm': volume_type_list.append( volume_type( name=swap_name, parent='', size='size:{0}'.format(swap_mbytes), fullsize=False, mountpoint=None, realpath='swap', label='SWAP', attributes=[], is_root_volume=False ) ) return volume_type_list
[docs] def get_volume_management(self) -> Optional[str]: """ Provides information which volume management system is used :return: name of volume manager :rtype: str """ volume_filesystems = ['btrfs'] selected_filesystem = self.build_type.get_filesystem() selected_system_disk = self.get_build_type_system_disk_section() volume_management = None if selected_system_disk and selected_system_disk.get_preferlvm(): # LVM volume management is preferred, use it volume_management = 'lvm' elif selected_filesystem in volume_filesystems: # specified filesystem has its own volume management system volume_management = selected_filesystem elif selected_system_disk: # systemdisk section is specified with non volume capable # filesystem and no volume management preference. So let's # use LVM by default volume_management = 'lvm' return volume_management
[docs] def get_drivers_list(self) -> List: """ List of driver names from all drivers sections matching configured profiles :return: driver names :rtype: list """ drivers_sections = self._profiled( self.xml_data.get_drivers() ) result = [] if drivers_sections: for driver in drivers_sections: for file_section in driver.get_file(): result.append(file_section.get_name()) return result
[docs] def get_strip_list(self, section_type: str) -> List: """ List of strip names matching the given section type and profiles :param str section_type: type name from packages section :return: strip names :rtype: list """ strip_sections = self._profiled( self.xml_data.get_strip() ) result = [] if strip_sections: for strip in strip_sections: if strip.get_type() == section_type: for file_section in strip.get_file(): result.append(file_section.get_name()) return result
[docs] def get_strip_files_to_delete(self) -> List: """ Items to delete from strip section :return: item names :rtype: list """ return self.get_strip_list('delete')
[docs] def get_strip_tools_to_keep(self) -> List: """ Tools to keep from strip section :return: tool names :rtype: list """ return self.get_strip_list('tools')
[docs] def get_strip_libraries_to_keep(self) -> List: """ Libraries to keep from strip section :return: librarie names :rtype: list """ return self.get_strip_list('libs')
[docs] def get_include_section_reference_file_names(self) -> List[str]: """ List of all <include> section file name references :return: List[str] :rtype: list """ include_files = [] for include in self.xml_data.get_include(): include_files.append(include.get_from()) return include_files
[docs] def get_repository_sections(self) -> List: """ List of all repository sections matching configured profiles :return: <repository> section reference(s) :rtype: list """ return self._profiled( self.xml_data.get_repository() )
[docs] def get_repository_sections_used_for_build(self) -> List: """ List of all repositorys sections used to build the image and matching configured profiles. :return: <repository> section reference(s) :rtype: list """ repos = self.get_repository_sections() return list( repo for repo in repos if not repo.get_imageonly() )
[docs] def get_repository_sections_used_in_image(self) -> List: """ List of all repositorys sections to be configured in the resulting image matching configured profiles. :return: <repository> section reference(s) :rtype: list """ repos = self.get_repository_sections() return list( repo for repo in repos if repo.get_imageinclude() or repo.get_imageonly() )
[docs] def delete_repository_sections(self) -> None: """ Delete all repository sections matching configured profiles """ self.xml_data.set_repository([])
[docs] def delete_repository_sections_used_for_build(self) -> None: """ Delete all repository sections used to build the image matching configured profiles """ used_for_build = self.get_repository_sections_used_for_build() all_repos = self.get_repository_sections() self.xml_data.set_repository( [ repo for repo in all_repos if repo not in used_for_build ] )
[docs] def get_repositories_signing_keys(self) -> List[str]: """ Get list of signing keys specified on the repositories """ key_file_list: List[str] = [] release_version = self.get_release_version() release_vars = [ '$releasever', '${releasever}' ] for repository in self.get_repository_sections() or []: for signing in repository.get_source().get_signing() or []: normalized_key_url = Uri(signing.get_key()).translate() if release_version: for release_var in release_vars: if release_var in normalized_key_url: normalized_key_url = normalized_key_url.replace( release_var, release_version ) if normalized_key_url not in key_file_list: key_file_list.append(normalized_key_url) return key_file_list
[docs] def set_repository( self, repo_source: str, repo_type: str, repo_alias: str, repo_prio: str, repo_imageinclude: bool = False, repo_package_gpgcheck: Optional[bool] = None, repo_signing_keys: List[str] = [], components: str = None, distribution: str = None, repo_gpgcheck: Optional[bool] = None ) -> None: """ Overwrite repository data of the first repository :param str repo_source: repository URI :param str repo_type: type name defined by schema :param str repo_alias: alias name :param str repo_prio: priority number, package manager specific :param bool repo_imageinclude: setup repository inside of the image :param bool repo_package_gpgcheck: enable/disable package gpg checks :param list repo_signing_keys: list of signing key file names :param str components: component names for debian repos :param str distribution: base distribution name for debian repos :param bool repo_gpgcheck: enable/disable repo gpg checks """ repository_sections = self.get_repository_sections() if repository_sections: repository = repository_sections[0] if repo_alias: repository.set_alias(repo_alias) if repo_type: repository.set_type(repo_type) if repo_source: repository.get_source().set_path(repo_source) if repo_prio: repository.set_priority(int(repo_prio)) if repo_imageinclude: repository.set_imageinclude(repo_imageinclude) if repo_package_gpgcheck is not None: repository.set_package_gpgcheck(repo_package_gpgcheck) if repo_signing_keys: repository.get_source().set_signing( [xml_parse.signing(key=k) for k in repo_signing_keys] ) if components: repository.set_components(components) if distribution: repository.set_distribution(distribution) if repo_gpgcheck is not None: repository.set_repository_gpgcheck(repo_gpgcheck)
[docs] def add_repository( self, repo_source: str, repo_type: str, repo_alias: str = None, repo_prio: str = '', repo_imageinclude: bool = False, repo_package_gpgcheck: Optional[bool] = None, repo_signing_keys: List[str] = [], components: str = None, distribution: str = None, repo_gpgcheck: Optional[bool] = None ) -> None: """ Add a new repository section at the end of the list :param str repo_source: repository URI :param str repo_type: type name defined by schema :param str repo_alias: alias name :param str repo_prio: priority number, package manager specific :param bool repo_imageinclude: setup repository inside of the image :param bool repo_package_gpgcheck: enable/disable package gpg checks :param list repo_signing_keys: list of signing key file names :param str components: component names for debian repos :param str distribution: base distribution name for debian repos :param bool repo_gpgcheck: enable/disable repo gpg checks """ priority_number: Optional[int] = None try: priority_number = int(repo_prio) except Exception: pass self.xml_data.add_repository( xml_parse.repository( type_=repo_type, alias=repo_alias, priority=priority_number, source=xml_parse.source( path=repo_source, signing=[ xml_parse.signing(key=k) for k in repo_signing_keys ] ), imageinclude=repo_imageinclude, package_gpgcheck=repo_package_gpgcheck, repository_gpgcheck=repo_gpgcheck, components=components, distribution=distribution ) )
[docs] def resolve_this_path(self) -> None: """ Resolve any this:// repo source path into the path representing the target inside of the image description directory """ for repository in self.get_repository_sections() or []: repo_source = repository.get_source() repo_path = repo_source.get_path() if repo_path.startswith('this://'): repo_path = repo_path.replace('this://', '') repo_source.set_path( 'dir://{0}'.format( os.path.realpath( os.path.join( self.xml_data.description_dir, repo_path ) ) ) )
[docs] def copy_displayname(self, target_state: Any) -> None: """ Copy image displayname from this xml state to the target xml state :param object target_state: XMLState instance """ displayname = self.xml_data.get_displayname() if displayname: target_state.xml_data.set_displayname(displayname)
[docs] def copy_name(self, target_state: Any) -> None: """ Copy image name from this xml state to the target xml state :param object target_state: XMLState instance """ target_state.xml_data.set_name( self.xml_data.get_name() )
[docs] def copy_drivers_sections(self, target_state: Any) -> None: """ Copy drivers sections from this xml state to the target xml state :param object target_state: XMLState instance """ drivers_sections = self._profiled( self.xml_data.get_drivers() ) if drivers_sections: for drivers_section in drivers_sections: target_state.xml_data.add_drivers(drivers_section)
[docs] def copy_systemdisk_section(self, target_state: Any) -> None: """ Copy systemdisk sections from this xml state to the target xml state :param object target_state: XMLState instance """ systemdisk_section = self.get_build_type_system_disk_section() if systemdisk_section: target_state.build_type.set_systemdisk( [systemdisk_section] )
[docs] def copy_strip_sections(self, target_state: Any) -> None: """ Copy strip sections from this xml state to the target xml state :param object target_state: XMLState instance """ strip_sections = self._profiled( self.xml_data.get_strip() ) if strip_sections: for strip_section in strip_sections: target_state.xml_data.add_strip(strip_section)
[docs] def copy_machine_section(self, target_state: Any) -> None: """ Copy machine sections from this xml state to the target xml state :param object target_state: XMLState instance """ machine_section = self.get_build_type_machine_section() if machine_section: target_state.build_type.set_machine( [machine_section] )
[docs] def copy_bootloader_section(self, target_state: Any) -> None: """ Copy bootloader section from this xml state to the target xml state :param object target_state: XMLState instance """ bootloader_section = self.get_build_type_bootloader_section() if bootloader_section: target_state.build_type.set_bootloader( [bootloader_section] )
[docs] def copy_oemconfig_section(self, target_state: Any) -> None: """ Copy oemconfig sections from this xml state to the target xml state :param object target_state: XMLState instance """ oemconfig_section = self.get_build_type_oemconfig_section() if oemconfig_section: target_state.build_type.set_oemconfig( [oemconfig_section] )
[docs] def copy_repository_sections( self, target_state: Any, wipe: bool = False ) -> None: """ Copy repository sections from this xml state to the target xml state :param object target_state: XMLState instance :param bool wipe: delete all repos in target prior to copy """ repository_sections = self._profiled( self.xml_data.get_repository() ) if repository_sections: if wipe: target_state.xml_data.set_repository([]) for repository_section in repository_sections: repository_copy = copy.deepcopy(repository_section) # profiles are not copied because they might not exist # in the target description repository_copy.set_profiles(None) target_state.xml_data.add_repository(repository_copy)
[docs] def copy_preferences_subsections( self, section_names: List, target_state: Any ) -> None: """ Copy subsections of the preferences sections, matching given section names, from this xml state to the target xml state :param list section_names: preferences subsection names :param object target_state: XMLState instance """ target_preferences_sections = target_state.get_preferences_sections() if target_preferences_sections: target_preferences_section = target_preferences_sections[0] for preferences_section in self.get_preferences_sections(): for section_name in section_names: get_section_method = getattr( preferences_section, 'get_' + section_name ) section = get_section_method() if section: set_section_method = getattr( target_preferences_section, 'set_' + section_name ) set_section_method(section)
[docs] def copy_build_type_attributes( self, attribute_names: List, target_state: Any ) -> None: """ Copy specified attributes from this build type section to the target xml state build type section :param list attribute_names: type section attributes :param object target_state: XMLState instance """ for attribute in attribute_names: get_type_method = getattr( self.build_type, 'get_' + attribute ) attribute_value = get_type_method() if attribute_value: set_type_method = getattr( target_state.build_type, 'set_' + attribute ) set_type_method(attribute_value)
[docs] def copy_bootincluded_packages(self, target_state: Any) -> None: """ Copy packages marked as bootinclude to the packages type=bootstrap section in the target xml state. The package will also be removed from the packages type=delete section in the target xml state if present there :param object target_state: XMLState instance """ target_packages_sections = \ target_state.get_bootstrap_packages_sections() if target_packages_sections: target_packages_section = \ target_packages_sections[0] package_names_added = [] packages_sections = self.get_packages_sections( ['image', 'bootstrap', self.get_build_type_name()] ) package_list = self.get_package_sections( packages_sections ) if package_list: for package in package_list: if package.package_section.get_bootinclude(): target_packages_section.add_package( xml_parse.package( name=package.package_section.get_name() ) ) package_names_added.append( package.package_section.get_name() ) delete_packages_sections = target_state.get_packages_sections( ['delete'] ) package_list = self.get_package_sections( delete_packages_sections ) if package_list: for package in package_list: package_name = package.package_section.get_name() if package_name in package_names_added: package.packages_section.package.remove( package.package_section )
[docs] def copy_bootincluded_archives(self, target_state: Any) -> None: """ Copy archives marked as bootinclude to the packages type=bootstrap section in the target xml state :param object target_state: XMLState instance """ target_bootstrap_packages_sections = \ target_state.get_bootstrap_packages_sections() if target_bootstrap_packages_sections: target_bootstrap_packages_section = \ target_bootstrap_packages_sections[0] packages_sections = self.get_packages_sections( ['image', 'bootstrap', self.get_build_type_name()] ) for packages_section in packages_sections: archive_list = packages_section.get_archive() if archive_list: for archive in archive_list: if archive.get_bootinclude(): target_bootstrap_packages_section.add_archive( xml_parse.archive( name=archive.get_name() ) )
[docs] def copy_bootdelete_packages(self, target_state: Any) -> None: """ Copy packages marked as bootdelete to the packages type=delete section in the target xml state :param object target_state: XMLState instance """ target_delete_packages_sections = target_state.get_packages_sections( ['delete'] ) if not target_delete_packages_sections: target_delete_packages_sections = [ xml_parse.packages(type_='delete') ] target_state.xml_data.add_packages( target_delete_packages_sections[0] ) target_delete_packages_section = \ target_delete_packages_sections[0] packages_sections = self.get_packages_sections( ['image', 'bootstrap', self.get_build_type_name()] ) package_list = self.get_package_sections( packages_sections ) if package_list: for package in package_list: if package.package_section.get_bootdelete(): target_delete_packages_section.add_package( xml_parse.package( name=package.package_section.get_name() ) )
[docs] def get_distribution_name_from_boot_attribute(self) -> str: """ Extract the distribution name from the boot attribute of the build type section. If no boot attribute is configured or the contents does not match the kiwi defined naming schema for boot image descriptions, an exception is thrown :return: lowercase distribution name :rtype: str """ boot_attribute = self.build_type.get_boot() if not boot_attribute: raise KiwiDistributionNameError( 'No boot attribute to extract distribution name from found' ) boot_attribute_format = '^.*-(.*)$' boot_attribute_expression = re.match( boot_attribute_format, boot_attribute ) if not boot_attribute_expression: raise KiwiDistributionNameError( 'Boot attribute "%s" does not match expected format %s' % (boot_attribute, boot_attribute_format) ) return boot_attribute_expression.group(1).lower()
[docs] def get_fs_mount_option_list(self) -> List: """ List of root filesystem mount options The list contains one element with the information from the fsmountoptions attribute. The value there is passed along to the -o mount option :return: max one element list with mount option string :rtype: list """ option_list = [] mount_options = self.build_type.get_fsmountoptions() if mount_options: option_list = [mount_options] return option_list
[docs] def get_fs_create_option_list(self) -> List: """ List of root filesystem creation options The list contains elements with the information from the fscreateoptions attribute string that got split into its substring components :return: list with create options :rtype: list """ option_list = [] create_options = self.build_type.get_fscreateoptions() if create_options: option_list = create_options.split() return option_list
[docs] def get_luks_credentials(self) -> Optional[str]: """ Return key or passphrase credentials to open the luks pool :return: data :rtype: str """ data = self.build_type.get_luks() if data: keyfile_name = None try: # try to interpret data as an URI uri = Uri(data) if not uri.is_remote(): keyfile_name = uri.translate() except Exception: # this doesn't look like a valid URI, continue as just data pass if keyfile_name: try: with open(keyfile_name) as keyfile: return keyfile.read() except Exception as issue: raise KiwiFileAccessError( f'Failed to read from {keyfile_name!r}: {issue}' ) return data
[docs] def get_luks_format_options(self) -> List[str]: """ Return list of luks format options :return: list of options :rtype: list """ result = [] luksversion = self.build_type.get_luks_version() luksformat = self.build_type.get_luksformat() luks_pbkdf = self.build_type.get_luks_pbkdf() if luksversion: result.append('--type') result.append(luksversion) if luksformat: for option in luksformat[0].get_option(): result.append(option.get_name()) if option.get_value(): result.append(option.get_value()) if luks_pbkdf: # Allow to override the pbkdf algorithm that cryptsetup # uses by default. Cryptsetup may use argon2i by default, # which is not supported by all bootloaders. result.append('--pbkdf') result.append(luks_pbkdf) return result
[docs] def get_derived_from_image_uri(self) -> Optional[Uri]: """ Uri object of derived image if configured Specific image types can be based on a master image. This method returns the location of this image when configured in the XML description :return: Instance of Uri :rtype: object """ derived_image = self.build_type.get_derived_from() if derived_image: return Uri(derived_image, repo_type='container') return None
[docs] def set_derived_from_image_uri(self, uri: str) -> None: """ Set derived_from attribute to a new value In order to set a new value the derived_from attribute must be already present in the image configuration :param str uri: URI """ if self.build_type.get_derived_from(): self.build_type.set_derived_from(uri) else: message = dedent('''\n No derived_from attribute configured in image <type> In order to set the uri {0} as base container reference an initial derived_from attribute must be set in the type section ''') log.warning(message.format(uri))
[docs] def set_root_partition_uuid(self, uuid: str) -> None: """ Store PARTUUID provided in uuid as state information :param str uuid: PARTUUID """ self.root_partition_uuid = uuid
[docs] def get_root_partition_uuid(self) -> Optional[str]: """ Return preserved PARTUUID """ return self.root_partition_uuid
[docs] def set_root_filesystem_uuid(self, uuid: str) -> None: """ Store UUID provided in uuid as state information :param str uuid: UUID """ self.root_filesystem_uuid = uuid
[docs] def get_root_filesystem_uuid(self) -> Optional[str]: """ Return preserved UUID """ return self.root_filesystem_uuid
[docs] @staticmethod def get_archives_target_dirs( packages_sections_names: Optional[List[xml_parse.packages]] ) -> Dict: """ Dict of archive names and target dirs for packages section(s), if any :return: archive names and its target dir :rtype: dict """ result = {} if packages_sections_names: for package_section_name in packages_sections_names: for archive in package_section_name.get_archive(): result[archive.get_name().strip()] = archive.get_target_dir() return result
[docs] def get_bootstrap_archives_target_dirs(self) -> Dict: """ Dict of archive names and target dirs from the type="bootstrap" packages section(s) :return: archive names and its target dir :rtype: dict """ return self.get_archives_target_dirs( self.get_packages_sections(['bootstrap']) )
[docs] def get_system_archives_target_dirs(self) -> Dict: """ Dict of archive names and its target dir from the packages sections matching type="image" and type=build_type :return: archive names and its target dir :rtype: dict """ return self.get_archives_target_dirs( self.get_packages_sections(['image', self.get_build_type_name()]) )
def _used_profiles(self, profiles=None): """ return list of profiles to use. The method looks up the profiles section in the XML description and searches for profiles matching the architecture. If no arch specifier is set the profile is considered to be valid for any arch If the profiles argument is not set only profiles marked with the attribute import=true will be selected. Profiles specified in the argument will take the highest priority and causes to skip the lookup of import profiles in the XML description :param list profiles: selected profile names """ available_profiles = dict() import_profiles = [] for profiles_section in self.xml_data.get_profiles(): for profile in profiles_section.get_profile(): if self.profile_matches_host_architecture(profile): name = profile.get_name() available_profiles[name] = profile if profile.get_import(): import_profiles.append(name) if not profiles: return import_profiles else: resolved_profiles = [] for profile in profiles: resolved_profiles += self._solve_profile_dependencies( profile, available_profiles, resolved_profiles ) return resolved_profiles def _section_matches_host_architecture(self, section): architectures = section.get_arch() if architectures: if self.host_architecture not in architectures.split(','): return False return True def _match_docker_base_data(self): container_config_section = self.get_build_type_containerconfig_section() container_base = {} if container_config_section: name = container_config_section.get_name() tag = container_config_section.get_tag() maintainer = container_config_section.get_maintainer() user = container_config_section.get_user() workingdir = container_config_section.get_workingdir() additional_names = container_config_section.get_additionalnames() if name: container_base['container_name'] = name if tag: container_base['container_tag'] = tag if additional_names: container_base['additional_names'] = additional_names.split(',') if maintainer: container_base['maintainer'] = maintainer if user: container_base['user'] = user if workingdir: container_base['workingdir'] = workingdir return container_base def _match_docker_entrypoint(self): container_config_section = self.get_build_type_containerconfig_section() container_entry = {} if container_config_section: entrypoint = container_config_section.get_entrypoint() if entrypoint and entrypoint[0].get_execute(): container_entry['entry_command'] = [ entrypoint[0].get_execute() ] argument_list = entrypoint[0].get_argument() if argument_list: for argument in argument_list: container_entry['entry_command'].append( argument.get_name() ) elif entrypoint and entrypoint[0].get_clear(): container_entry['entry_command'] = [] return container_entry def _match_docker_subcommand(self): container_config_section = self.get_build_type_containerconfig_section() container_subcommand = {} if container_config_section: subcommand = container_config_section.get_subcommand() if subcommand and subcommand[0].get_execute(): container_subcommand['entry_subcommand'] = [ subcommand[0].get_execute() ] argument_list = subcommand[0].get_argument() if argument_list: for argument in argument_list: container_subcommand['entry_subcommand'].append( argument.get_name() ) elif subcommand and subcommand[0].get_clear(): container_subcommand['entry_subcommand'] = [] return container_subcommand def _match_docker_expose_ports(self): container_config_section = self.get_build_type_containerconfig_section() container_expose = {} if container_config_section: expose = container_config_section.get_expose() if expose and expose[0].get_port(): container_expose['expose_ports'] = [] for port in expose[0].get_port(): container_expose['expose_ports'].append( format(port.get_number()) ) return container_expose def _match_docker_volumes(self): container_config_section = self.get_build_type_containerconfig_section() container_volumes = {} if container_config_section: volumes = container_config_section.get_volumes() if volumes and volumes[0].get_volume(): container_volumes['volumes'] = [] for volume in volumes[0].get_volume(): container_volumes['volumes'].append(volume.get_name()) return container_volumes def _match_docker_environment(self): container_config_section = self.get_build_type_containerconfig_section() container_env = {} if container_config_section: environment = container_config_section.get_environment() if environment and environment[0].get_env(): container_env['environment'] = {} for env in environment[0].get_env(): container_env['environment'][env.get_name()] = \ env.get_value() return container_env def _match_docker_labels(self): container_config_section = self.get_build_type_containerconfig_section() container_labels = {} if container_config_section: labels = container_config_section.get_labels() if labels and labels[0].get_label(): container_labels['labels'] = {} for label in labels[0].get_label(): container_labels['labels'][label.get_name()] = \ label.get_value() return container_labels def _match_docker_history(self): container_config_section = self.get_build_type_containerconfig_section() container_history = {} if container_config_section: history = container_config_section.get_history() if history: container_history['history'] = {} if history[0].get_created_by(): container_history['history']['created_by'] = \ history[0].get_created_by() if history[0].get_author(): container_history['history']['author'] = \ history[0].get_author() if history[0].get_launcher(): container_history['history']['launcher'] = \ history[0].get_launcher() if history[0].get_application_id(): container_history['history']['application_id'] = \ history[0].get_application_id() if history[0].get_package_version(): container_history['history']['package_version'] = \ history[0].get_package_version() container_history['history']['comment'] = \ history[0].get_valueOf_() return container_history def _solve_profile_dependencies( self, profile, available_profiles, current_profiles ): if profile not in available_profiles: raise KiwiProfileNotFound( 'profile {0} not found for host arch {1}'.format( profile, self.host_architecture ) ) profiles_to_add = [] if profile not in current_profiles: profiles_to_add.append(profile) for required in available_profiles[profile].get_requires(): if required.get_profile() not in current_profiles: profiles_to_add += self._solve_profile_dependencies( required.get_profile(), available_profiles, current_profiles + profiles_to_add ) return profiles_to_add def _build_type_section(self, build_type=None): """ find type section matching build type and profiles or default """ # lookup all preferences sections for selected profiles image_type_sections = [] for preferences in self.get_preferences_sections(): image_type_sections += preferences.get_type() # lookup if build type matches provided type if build_type: for image_type in image_type_sections: if build_type == image_type.get_image(): return image_type raise KiwiTypeNotFound( 'Build type {0!r} not found for applied profiles: {1!r}'.format( build_type, self.profiles ) ) # lookup if build type matches primary type for image_type in image_type_sections: if image_type.get_primary(): return image_type # build type is first type section in XML sequence if image_type_sections: return image_type_sections[0] raise KiwiTypeNotFound( 'No build type defined with applied profiles: {0!r}'.format( self.profiles ) ) def _profiled(self, xml_abstract): """ return only those sections matching the instance stored profile list from the given XML abstract. Sections without a profile are wildcard sections and will be used in any case """ result = [] for section in xml_abstract: profiles = section.get_profiles() if profiles: for profile in profiles.split(','): if self.profiles and profile in self.profiles: result.append(section) break else: result.append(section) return result def _to_volume_name(self, name): name = name.strip() name = re.sub(r'^\/+', r'', name) name = name.replace('/', '_') return name def _to_mega_byte(self, size): value = re.search(r'(\d+)([MG]*)', format(size)) if value: number = value.group(1) unit = value.group(2) if unit == 'G': return int(number) * 1024 else: return int(number) else: return size