def setup(self, volume_group_name='systemVG'):
"""
Setup lvm volume management
In case of LVM a new volume group is created on a PV
initialized storage device
:param string name: volume group name
"""
self.setup_mountpoint()
if self._volume_group_in_use_on_host_system(volume_group_name):
raise KiwiVolumeGroupConflict(
'Requested volume group %s is in use on this host' %
volume_group_name
)
log.info(
'Creating volume group %s', volume_group_name
)
Command.run(
command=['vgremove', '--force', volume_group_name],
raise_on_error=False
)
Command.run(['pvcreate', self.device])
Command.run(['vgcreate', volume_group_name, self.device])
self.volume_group = volume_group_name
def setup_locale(self):
"""
Setup UTF8 system wide locale
"""
if 'locale' in self.preferences:
if 'POSIX' in self.preferences['locale'].split(','):
locale = 'POSIX'
else:
locale = '{0}.UTF-8'.format(
self.preferences['locale'].split(',')[0]
)
log.info('Setting up locale: %s', self.preferences['locale'])
if CommandCapabilities.has_option_in_help(
'systemd-firstboot', '--locale',
root=self.root_dir, raise_on_error=False
):
Path.wipe(self.root_dir + '/etc/locale.conf')
Command.run([
'chroot', self.root_dir, 'systemd-firstboot',
'--locale=' + locale
])
elif os.path.exists(self.root_dir + '/etc/sysconfig/language'):
Shell.run_common_function(
'baseUpdateSysConfig', [
self.root_dir + '/etc/sysconfig/language',
'RC_LANG', locale
]
)
else:
log.warning(
'locale setup skipped no capable '
'systemd-firstboot or etc/sysconfig/language not found'
)
def create_install_media(self, result_instance):
"""
Build an installation image. The installation image is a
bootable hybrid ISO image which embeds the raw disk image
and an image installer
"""
if self.install_media:
install_image = InstallImageBuilder(
self.xml_state, self.root_dir, self.target_dir,
self._load_boot_image_instance(), self.custom_args
)
if self.install_iso or self.install_stick:
log.info('Creating hybrid ISO installation image')
install_image.create_install_iso()
result_instance.add(
key='installation_image',
filename=install_image.isoname,
use_for_bundle=True,
compress=False,
shasum=True
)
if self.install_pxe:
log.info('Creating PXE installation archive')
install_image.create_install_pxe_archive()
result_instance.add(
key='installation_pxe_archive',
filename=install_image.pxename,
use_for_bundle=True,
compress=False,
shasum=True
)
return result_instance
def _build_boot_filesystems(self, device_map):
if 'efi' in device_map:
log.info(
'Creating EFI(fat16) filesystem on %s',
device_map['efi'].get_device()
)
filesystem = FileSystem(
'fat16', device_map['efi'], self.root_dir + '/boot/efi/'
)
filesystem.create_on_device(
label=self.disk_setup.get_efi_label()
)
self.system_efi = filesystem
if 'boot' in device_map:
boot_filesystem = self.requested_boot_filesystem
if not boot_filesystem:
boot_filesystem = self.requested_filesystem
boot_directory = self.root_dir + '/boot/'
if self.bootloader == 'grub2_s390x_emu':
boot_directory = self.root_dir + '/boot/zipl/'
boot_filesystem = 'ext2'
log.info(
'Creating boot(%s) filesystem on %s',
boot_filesystem, device_map['boot'].get_device()
)
filesystem = FileSystem(
boot_filesystem, device_map['boot'], boot_directory
)
filesystem.create_on_device(
label=self.disk_setup.get_boot_label()
)
self.system_boot = filesystem
def install_packages(self, manager, packages):
"""
Install one or more packages using the package manager inside
of the new root directory
:param object manager: instance of a :class:`PackageManager` subclass
:param list packages: package list
:raises KiwiSystemInstallPackagesFailed: if installation process fails
"""
log.info('Installing system packages (chroot)')
all_install_items = self._setup_requests(
manager, packages
)
if all_install_items:
process = CommandProcess(
command=manager.process_install_requests(), log_topic='system'
)
try:
process.poll_show_progress(
items_to_complete=all_install_items,
match_method=process.create_match_method(
manager.match_package_installed
)
)
except Exception as e:
raise KiwiSystemInstallPackagesFailed(
'Package installation failed: %s' % format(e)
)
def setup_disk_boot_images(self, boot_uuid, lookup_path=None):
"""
Create/Provide grub2 boot images and metadata
In order to boot from the disk grub2 modules, images and theme
data needs to be created and provided at the correct place in
the filesystem
:param string boot_uuid: boot device UUID
:param string lookup_path: custom module lookup path
"""
log.info('Creating grub2 bootloader images')
if self.firmware.efi_mode():
self.efi_boot_path = self.create_efi_path()
self._copy_theme_data_to_boot_directory(lookup_path)
if not self.xen_guest and self._supports_bios_modules():
self._copy_bios_modules_to_boot_directory(lookup_path)
if self.firmware.efi_mode() == 'efi':
self._setup_efi_image(uuid=boot_uuid, lookup_path=lookup_path)
self._copy_efi_modules_to_boot_directory(lookup_path)
elif self.firmware.efi_mode() == 'uefi':
self._copy_efi_modules_to_boot_directory(lookup_path)
if not self._get_shim_install():
self.shim_fallback_setup = True
self._setup_secure_boot_efi_image(lookup_path)
if self.xen_guest:
self._copy_xen_modules_to_boot_directory(lookup_path)
def create_degraded_raid(self, raid_level):
"""
Create a raid array in degraded mode with one device missing.
This only works in the raid levels 0(striping) and 1(mirroring)
:param string raid_level: raid level name
"""
if raid_level not in self.raid_level_map:
raise KiwiRaidSetupError(
'Only raid levels 0(striping) and 1(mirroring) are supported'
)
raid_device = None
for raid_id in range(9):
raid_device = '/dev/md' + format(raid_id)
if os.path.exists(raid_device):
raid_device = None
else:
break
if not raid_device:
raise KiwiRaidSetupError(
'Could not find free raid device in range md0-8'
)
log.info(
'Creating raid array in %s mode as %s',
raid_level, raid_device
)
Command.run(
[
'mdadm', '--create', '--run', raid_device,
'--level', self.raid_level_map[raid_level],
'--raid-disks', '2',
self.storage_provider.get_device(), 'missing'
]
)
self.raid_device = raid_device
def setup_keyboard_map(self):
"""
Setup console keyboard
"""
if 'keytable' in self.preferences:
log.info(
'Setting up keytable: %s', self.preferences['keytable']
)
if CommandCapabilities.has_option_in_help(
'systemd-firstboot', '--keymap',
root=self.root_dir, raise_on_error=False
):
Path.wipe(self.root_dir + '/etc/vconsole.conf')
Command.run([
'chroot', self.root_dir, 'systemd-firstboot',
'--keymap=' + self.preferences['keytable']
])
elif os.path.exists(self.root_dir + '/etc/sysconfig/keyboard'):
Shell.run_common_function(
'baseUpdateSysConfig', [
self.root_dir + '/etc/sysconfig/keyboard', 'KEYTABLE',
'"' + self.preferences['keytable'] + '"'
]
)
else:
log.warning(
'keyboard setup skipped no capable '
'systemd-firstboot or etc/sysconfig/keyboard found'
)
def _setup_jobs(self, job_names, skip_missing):
"""
Create a solver job list from given list of job names
:param list job_names: list of package,pattern,group names
:param bool skip_missing: continue or raise if job selection failed
:rtype: list
:return: list of Pool.selection() objects
"""
jobs = []
for job_name in job_names:
selection = self.pool.select(
job_name,
self.solv.Selection.SELECTION_NAME |
self.solv.Selection.SELECTION_PROVIDES
)
if selection.flags() & self.solv.Selection.SELECTION_PROVIDES:
log.info('--> Using capability match for {0}'.format(job_name))
if selection.isempty():
if skip_missing:
log.info(
'--> Package {0} not found: skipped'.format(job_name)
)
else:
raise KiwiSatSolverJobError(
'Package {0} not found'.format(job_name)
)
else:
jobs += selection.jobs(self.solv.Job.SOLVER_INSTALL)
return jobs
def __init__(
self, xml_state, root_dir, allow_existing=False
):
"""
Setup and host bind new root system at given root_dir directory
"""
log.info('Setup root directory: %s', root_dir)
root = RootInit(
root_dir, allow_existing
)
root.create()
image_uri = xml_state.get_derived_from_image_uri()
if image_uri:
root_import = RootImport(
root_dir, image_uri, xml_state.build_type.get_image()
)
root_import.sync_data()
root_bind = RootBind(
root
)
root_bind.setup_intermediate_config()
root_bind.mount_kernel_file_systems()
root_bind.mount_shared_directory()
self.xml_state = xml_state
self.profiles = xml_state.profiles
self.root_bind = root_bind
# A list of Uri references is stored inside of the System instance
# in order to delay the Uri destructors until the System instance
# dies. This is needed to keep bind mounted Uri locations alive
# for System operations
self.uri_list = []
def delete_packages(self, manager, packages, force=False):
"""
Delete one or more packages using the package manager inside
of the new root directory. If the removal is set with `force` flag
only listed packages are deleted and any dependency break or leftover
is ignored.
:param object manager: instance of a :class:`PackageManager` subclass
:param list packages: package list
:param bool force: force deletion true|false
:raises KiwiSystemDeletePackagesFailed: if installation process fails
"""
log.info('{0} system packages (chroot)'.format(
'Force deleting' if force else 'Uninstall'
))
all_delete_items = self._setup_requests(
manager, packages
)
if all_delete_items:
process = CommandProcess(
command=manager.process_delete_requests(force),
log_topic='system'
)
try:
process.poll_show_progress(
items_to_complete=all_delete_items,
match_method=process.create_match_method(
manager.match_package_deleted
)
)
except Exception as e:
raise KiwiSystemDeletePackagesFailed(
'Package deletion failed: %s' % format(e)
)
def _get_root_cmdline_parameter(self, uuid):
firmware = self.xml_state.build_type.get_firmware()
initrd_system = self.xml_state.get_initrd_system()
cmdline = self.xml_state.build_type.get_kernelcmdline()
if cmdline and 'root=' in cmdline:
log.info(
'Kernel root device explicitly set via kernelcmdline'
)
return None
want_root_cmdline_parameter = False
if firmware and 'ec2' in firmware:
# EC2 requires to specifiy the root device in the bootloader
# configuration. This is because the used pvgrub or hvmloader
# reads this information and passes it to the guest configuration
# which has an impact on the devices attached to the guest.
want_root_cmdline_parameter = True
if initrd_system == 'dracut':
# When using a dracut initrd we have to specify the location
# of the root device
want_root_cmdline_parameter = True
if want_root_cmdline_parameter:
if uuid and self.xml_state.build_type.get_overlayroot():
return 'root=overlay:UUID={0}'.format(uuid)
elif uuid:
return 'root=UUID={0} rw'.format(uuid)
else:
log.warning(
'root=UUID=<uuid> setup requested, but uuid is not provided'
)
def pinch_system(self, manager=None, force=False):
"""
Delete packages marked for deletion in the XML description. If force
param is set to False uninstalls packages marked with
`type="uninstall"` if any; if force is set to True deletes packages
marked with `type="delete"` if any.
:param object manager: instance of :class:`PackageManager`
:param bool force: Forced deletion True|False
:raises KiwiPackagesDeletePhaseFailed: if the deletion packages
process fails
"""
to_become_deleted_packages = \
self.xml_state.get_to_become_deleted_packages(force)
try:
if to_become_deleted_packages:
log.info('{0} system packages (chroot)'.format(
'Force deleting' if force else 'Uninstalling')
)
if manager is None:
package_manager = self.xml_state.get_package_manager()
manager = PackageManager(
Repository(self.root_bind, package_manager),
package_manager
)
self.delete_packages(
manager, to_become_deleted_packages, force
)
except Exception as e:
raise KiwiPackagesDeletePhaseFailed(
'%s: %s' % (type(e).__name__, format(e))
)
def print_results(self):
"""
Print results human readable
"""
if self.result_files:
log.info('Result files:')
for key, value in sorted(list(self.result_files.items())):
log.info('--> %s: %s', key, value.filename)
def create(self):
"""
Build a mountable filesystem image
Image types which triggers this builder are:
* image="ext2"
* image="ext3"
* image="ext4"
* image="btrfs"
* image="xfs"
:return: result
:rtype: instance of :class:`Result`
"""
log.info(
'Creating %s filesystem', self.requested_filesystem
)
supported_filesystems = Defaults.get_filesystem_image_types()
if self.requested_filesystem not in supported_filesystems:
raise KiwiFileSystemSetupError(
'Unknown filesystem: %s' % self.requested_filesystem
)
if self.requested_filesystem not in self.filesystems_no_device_node:
self._operate_on_loop()
else:
self._operate_on_file()
self.result.verify_image_size(
self.runtime_config.get_max_size_constraint(),
self.filename
)
self.result.add(
key='filesystem_image',
filename=self.filename,
use_for_bundle=True,
compress=True,
shasum=True
)
self.result.add(
key='image_packages',
filename=self.system_setup.export_package_list(
self.target_dir
),
use_for_bundle=True,
compress=False,
shasum=False
)
self.result.add(
key='image_verified',
filename=self.system_setup.export_package_verification(
self.target_dir
),
use_for_bundle=True,
compress=False,
shasum=False
)
return self.result
def install_system(self, manager):
"""
Install system software using the package manager inside
of the new root directory. This is done via a chroot operation
and requires the desired package manager to became installed
via the bootstrap phase
:param object manager: instance of a :class:`PackageManager` subclass
:raises KiwiInstallPhaseFailed: if the install process fails
either installing packages or including any archive
"""
log.info(
'Installing system (chroot) for build type: %s',
self.xml_state.get_build_type_name()
)
collection_type = self.xml_state.get_system_collection_type()
log.info('--> collection type: %s', collection_type)
system_packages = self.xml_state.get_system_packages()
system_collections = self.xml_state.get_system_collections()
system_products = self.xml_state.get_system_products()
system_archives = self.xml_state.get_system_archives()
system_packages_ignored = self.xml_state.get_system_ignore_packages()
# process package installations
if collection_type == 'onlyRequired':
manager.process_only_required()
else:
manager.process_plus_recommended()
all_install_items = self._setup_requests(
manager,
system_packages,
system_collections,
system_products,
system_packages_ignored
)
if all_install_items:
process = CommandProcess(
command=manager.process_install_requests(), log_topic='system'
)
try:
process.poll_show_progress(
items_to_complete=all_install_items,
match_method=process.create_match_method(
manager.match_package_installed
)
)
except Exception as e:
raise KiwiInstallPhaseFailed(
'System package installation failed: %s' % format(e)
)
# process archive installations
if system_archives:
try:
self._install_archives(system_archives)
except Exception as e:
raise KiwiInstallPhaseFailed(
'System archive installation failed: %s' % format(e)
)
def __del__(self):
if self.media_dir or self.live_container_dir:
log.info(
'Cleaning up {0} instance'.format(type(self).__name__)
)
if self.media_dir:
Path.wipe(self.media_dir)
if self.live_container_dir:
Path.wipe(self.live_container_dir)
def __del__(self):
if self.node_name:
log.info('Cleaning up %s instance', type(self).__name__)
try:
Command.run(['losetup', '-d', self.node_name])
except Exception:
log.warning(
'loop device %s still busy', self.node_name
)
def _write_raid_config_to_boot_image(self):
if self.mdraid:
log.info('Creating etc/mdadm.conf in boot system')
filename = ''.join(
[self.boot_image.boot_root_directory, '/etc/mdadm.conf']
)
self.raid_root.create_raid_config(filename)
self.boot_image.include_file(
os.sep + os.sep.join(['etc', os.path.basename(filename)])
)
def _write_crypttab_to_system_image(self):
if self.luks:
log.info('Creating etc/crypttab')
filename = ''.join(
[self.root_dir, '/etc/crypttab']
)
self.luks_root.create_crypttab(filename)
self.boot_image.include_file(
os.sep + os.sep.join(['etc', os.path.basename(filename)])
)
def import_image_identifier(self):
"""
Create etc/ImageID identifier file
"""
image_id = self.xml_state.xml_data.get_id()
if image_id and os.path.exists(self.root_dir + '/etc'):
image_id_file = self.root_dir + '/etc/ImageID'
log.info('Creating identifier: %s as %s', image_id, image_id_file)
with open(image_id_file, 'w') as identifier:
identifier.write('%s\n' % image_id)
def __del__(self):
log.info('Cleaning up %s instance', type(self).__name__)
if self.initrd_system == 'dracut':
self._delete_dracut_install_config()
if self.media_dir:
Path.wipe(self.media_dir)
if self.pxe_dir:
Path.wipe(self.pxe_dir)
if self.squashed_contents:
Path.wipe(self.squashed_contents)
def setup_groups(self):
"""
Add groups for configured users
"""
system_users = Users(self.root_dir)
for user in self.xml_state.get_users():
for group in self.xml_state.get_user_groups(user.get_name()):
if not system_users.group_exists(group):
log.info('Adding group %s', group)
system_users.group_add(group, [])
def __del__(self):
if self.storage_provider.is_loop() and self.is_mapped:
log.info('Cleaning up %s instance', type(self).__name__)
try:
for device_node in self.partition_map.values():
Command.run(['dmsetup', 'remove', device_node])
except Exception:
log.warning(
'cleanup of partition device maps failed, %s still busy',
self.storage_provider.get_device()
)
def _export_deb_package_verification(self, filename):
log.info('Export deb verification metadata')
query_call = Command.run(
command=[
'dpkg', '--root', self.root_dir,
'-V', '--verify-format', 'rpm'
],
raise_on_error=False
)
with open(filename, 'w') as verified:
verified.write(query_call.output)
def create_volumes(self, filesystem_name):
"""
Create configured btrfs subvolumes
Any btrfs subvolume is of the same btrfs filesystem. There is no
way to have different filesystems per btrfs subvolume. Thus
the filesystem_name has no effect for btrfs
:param string filesystem_name: unused
"""
log.info(
'Creating %s sub volumes', filesystem_name
)
self.create_volume_paths_in_root_dir()
canonical_volume_list = self.get_canonical_volume_list()
if canonical_volume_list.full_size_volume:
# put an eventual fullsize volume to the volume list
# because there is no extra handling required for it on btrfs
canonical_volume_list.volumes.append(
canonical_volume_list.full_size_volume
)
for volume in canonical_volume_list.volumes:
if volume.name == 'LVRoot':
# the btrfs root volume named '@' has been created as
# part of the setup procedure
pass
else:
log.info('--> sub volume %s', volume.realpath)
toplevel = self.mountpoint + '/@/'
volume_parent_path = os.path.normpath(
toplevel + os.path.dirname(volume.realpath)
)
if not os.path.exists(volume_parent_path):
Path.create(volume_parent_path)
Command.run(
[
'btrfs', 'subvolume', 'create',
os.path.normpath(toplevel + volume.realpath)
]
)
self.apply_attributes_on_volume(
toplevel, volume
)
if self.custom_args['root_is_snapshot']:
snapshot = self.mountpoint + '/@/.snapshots/1/snapshot/'
volume_mount = MountManager(
device=self.device,
mountpoint=os.path.normpath(snapshot + volume.realpath)
)
self.subvol_mount_list.append(
volume_mount
)
def __del__(self):
if self.volume_group:
log.info('Cleaning up %s instance', type(self).__name__)
if self.umount_volumes():
Path.wipe(self.mountpoint)
try:
Command.run(['vgchange', '-an', self.volume_group])
except Exception:
log.warning(
'volume group %s still busy', self.volume_group
)
def apply_attributes_on_volume(self, toplevel, volume):
for attribute in volume.attributes:
if attribute == 'no-copy-on-write':
log.info(
'--> setting {0} for {1}'.format(attribute, volume.realpath)
)
Command.run(
[
'chattr', '+C',
os.path.normpath(toplevel + volume.realpath)
]
)
def __del__(self):
if self.luks_device:
log.info('Cleaning up %s instance', type(self).__name__)
try:
Command.run(
['cryptsetup', 'luksClose', self.luks_name]
)
except Exception:
log.warning(
'Shutdown of luks map %s failed, %s still busy',
self.luks_name, self.luks_device
)
def __del__(self):
if self.raid_device:
log.info('Cleaning up %s instance', type(self).__name__)
try:
Command.run(
['mdadm', '--stop', self.raid_device]
)
except Exception:
log.warning(
'Shutdown of raid device failed, %s still busy',
self.raid_device
)
def process(self): # noqa: C901
"""
Prepare and install a new system for chroot access
"""
self.manual = Help()
if self._help():
return
Privileges.check_for_root_permissions()
self.load_xml_description(
self.command_args['--description']
)
abs_root_path = os.path.abspath(self.command_args['--root'])
prepare_checks = self.checks_before_command_args
prepare_checks.update(
{
'check_target_directory_not_in_shared_cache': [abs_root_path]
}
)
self.run_checks(prepare_checks)
if self.command_args['--ignore-repos']:
self.xml_state.delete_repository_sections()
elif self.command_args['--ignore-repos-used-for-build']:
self.xml_state.delete_repository_sections_used_for_build()
if self.command_args['--set-repo']:
self.xml_state.set_repository(
*self.sextuple_token(self.command_args['--set-repo'])
)
if self.command_args['--add-repo']:
for add_repo in self.command_args['--add-repo']:
self.xml_state.add_repository(
*self.sextuple_token(add_repo)
)
if self.command_args['--set-container-tag']:
self.xml_state.set_container_config_tag(
self.command_args['--set-container-tag']
)
if self.command_args['--add-container-label']:
for add_label in self.command_args['--add-container-label']:
try:
(name, value) = add_label.split('=', 1)
self.xml_state.add_container_config_label(name, value)
except Exception:
log.warning(
'Container label {0} ignored. Invalid format: '
'expected labelname=value'.format(add_label)
)
if self.command_args['--set-container-derived-from']:
self.xml_state.set_derived_from_image_uri(
self.command_args['--set-container-derived-from']
)
self.run_checks(self.checks_after_command_args)
log.info('Preparing system')
system = SystemPrepare(
self.xml_state,
abs_root_path,
self.command_args['--allow-existing-root']
)
manager = system.setup_repositories(
self.command_args['--clear-cache'],
self.command_args['--signing-key']
)
system.install_bootstrap(manager)
system.install_system(
manager
)
if self.command_args['--add-package']:
system.install_packages(
manager, self.command_args['--add-package']
)
if self.command_args['--delete-package']:
system.delete_packages(
manager, self.command_args['--delete-package']
)
profile = Profile(self.xml_state)
defaults = Defaults()
defaults.to_profile(profile)
setup = SystemSetup(
self.xml_state, abs_root_path
)
setup.import_shell_environment(profile)
setup.import_description()
setup.import_overlay_files()
setup.import_image_identifier()
setup.setup_groups()
setup.setup_users()
setup.setup_keyboard_map()
setup.setup_locale()
setup.setup_plymouth_splash()
setup.setup_timezone()
setup.setup_permissions()
# make sure manager instance is cleaned up now
del manager
# setup permanent image repositories after cleanup
setup.import_repositories_marked_as_imageinclude()
setup.call_config_script()
# handle uninstall package requests, gracefully uninstall
# with dependency cleanup
system.pinch_system(force=False)
# handle delete package requests, forced uninstall without
# any dependency resolution
system.pinch_system(force=True)
# delete any custom rpm macros created
Rpm(
abs_root_path, Defaults.get_custom_rpm_image_macro_name()
).wipe_config()
# make sure system instance is cleaned up now
del system
def setup_live_image_config(self,
mbrid,
hypervisor='xen.gz',
kernel='linux',
initrd='initrd'):
"""
Create grub2 config file to boot a live media ISO image
:param string mbrid: mbrid file name on boot device
:param string hypervisor: hypervisor name
:param string kernel: kernel name
:param string initrd: initrd name
"""
log.info('Creating grub2 live ISO config file from template')
self.iso_boot = True
self.cmdline = self.get_boot_cmdline()
self.cmdline_failsafe = ' '.join(
[self.cmdline,
Defaults.get_failsafe_kernel_options()])
parameters = {
'search_params':
'--file --set=root /boot/' + mbrid.get_id(),
'default_boot':
'0',
'kernel_file':
kernel,
'initrd_file':
initrd,
'boot_options':
' '.join([self.cmdline] + self.live_boot_options),
'failsafe_boot_options':
' '.join([self.cmdline_failsafe] + self.live_boot_options),
'gfxmode':
self.gfxmode,
'theme':
self.theme,
'boot_timeout':
self.timeout,
'title':
self.get_menu_entry_title(plain=True),
'bootpath':
self.get_boot_path('iso'),
'boot_directory_name':
self.boot_directory_name,
'efi_image_name':
Defaults.get_efi_image_name(self.arch)
}
if self.multiboot:
log.info('--> Using multiboot template')
parameters['hypervisor'] = hypervisor
template = self.grub2.get_multiboot_iso_template(
self.failsafe_boot, self.terminal, self.mediacheck_boot)
else:
log.info('--> Using standard boot template')
hybrid_boot = True
template = self.grub2.get_iso_template(self.failsafe_boot,
hybrid_boot, self.terminal,
self.mediacheck_boot)
try:
self.config = template.substitute(parameters)
except Exception as e:
raise KiwiTemplateError('%s: %s' % (type(e).__name__, format(e)))
def process(self): # noqa: C901
"""
Build a system image from the specified description. The
build command combines the prepare and create commands
"""
self.manual = Help()
if self._help():
return
Privileges.check_for_root_permissions()
abs_target_dir_path = os.path.abspath(
self.command_args['--target-dir']
)
build_dir = os.sep.join([abs_target_dir_path, 'build'])
image_root = os.sep.join([build_dir, 'image-root'])
Path.create(build_dir)
if not self.global_args['--logfile']:
log.set_logfile(
os.sep.join([abs_target_dir_path, 'build', 'image-root.log'])
)
self.load_xml_description(
self.command_args['--description']
)
self.runtime_checker.check_minimal_required_preferences()
self.runtime_checker.check_efi_mode_for_disk_overlay_correctly_setup()
self.runtime_checker.check_boot_description_exists()
self.runtime_checker.check_consistent_kernel_in_boot_and_system_image()
self.runtime_checker.check_docker_tool_chain_installed()
self.runtime_checker.check_volume_setup_defines_multiple_fullsize_volumes()
self.runtime_checker.check_volume_setup_has_no_root_definition()
self.runtime_checker.check_volume_label_used_with_lvm()
self.runtime_checker.check_xen_uniquely_setup_as_server_or_guest()
self.runtime_checker.check_target_directory_not_in_shared_cache(
abs_target_dir_path
)
self.runtime_checker.check_mediacheck_only_for_x86_arch()
self.runtime_checker.check_dracut_module_for_live_iso_in_package_list()
self.runtime_checker.check_dracut_module_for_disk_overlay_in_package_list()
self.runtime_checker.check_dracut_module_for_disk_oem_in_package_list()
self.runtime_checker.check_dracut_module_for_oem_install_in_package_list()
if self.command_args['--ignore-repos']:
self.xml_state.delete_repository_sections()
elif self.command_args['--ignore-repos-used-for-build']:
self.xml_state.delete_repository_sections_used_for_build()
if self.command_args['--set-repo']:
self.xml_state.set_repository(
*self.sextuple_token(self.command_args['--set-repo'])
)
if self.command_args['--add-repo']:
for add_repo in self.command_args['--add-repo']:
self.xml_state.add_repository(
*self.sextuple_token(add_repo)
)
if self.command_args['--set-container-tag']:
self.xml_state.set_container_config_tag(
self.command_args['--set-container-tag']
)
if self.command_args['--add-container-label']:
for add_label in self.command_args['--add-container-label']:
try:
(name, value) = add_label.split('=', 1)
self.xml_state.add_container_config_label(name, value)
except Exception:
log.warning(
'Container label {0} ignored. Invalid format: '
'expected labelname=value'.format(add_label)
)
if self.command_args['--set-container-derived-from']:
self.xml_state.set_derived_from_image_uri(
self.command_args['--set-container-derived-from']
)
self.runtime_checker.check_repositories_configured()
self.runtime_checker.check_image_include_repos_publicly_resolvable()
log.info('Preparing new root system')
system = SystemPrepare(
self.xml_state,
image_root,
self.command_args['--allow-existing-root']
)
manager = system.setup_repositories(
self.command_args['--clear-cache'],
self.command_args['--signing-key']
)
system.install_bootstrap(manager)
system.install_system(
manager
)
if self.command_args['--add-package']:
system.install_packages(
manager, self.command_args['--add-package']
)
if self.command_args['--delete-package']:
system.delete_packages(
manager, self.command_args['--delete-package']
)
profile = Profile(self.xml_state)
defaults = Defaults()
defaults.to_profile(profile)
setup = SystemSetup(
self.xml_state, image_root
)
setup.import_shell_environment(profile)
setup.import_description()
setup.import_overlay_files()
setup.import_image_identifier()
setup.setup_groups()
setup.setup_users()
setup.setup_keyboard_map()
setup.setup_locale()
setup.setup_plymouth_splash()
setup.setup_timezone()
setup.setup_permissions()
# make sure manager instance is cleaned up now
del manager
# setup permanent image repositories after cleanup
setup.import_repositories_marked_as_imageinclude()
setup.call_config_script()
# handle uninstall package requests, gracefully uninstall
# with dependency cleanup
system.pinch_system(force=False)
# handle delete package requests, forced uninstall without
# any dependency resolution
system.pinch_system(force=True)
# delete any custom rpm macros created
Rpm(
image_root, Defaults.get_custom_rpm_image_macro_name()
).wipe_config()
# make sure system instance is cleaned up now
del system
setup.call_image_script()
# make sure setup instance is cleaned up now
del setup
log.info('Creating system image')
image_builder = ImageBuilder(
self.xml_state,
abs_target_dir_path,
image_root,
custom_args={
'signing_keys': self.command_args['--signing-key'],
'xz_options': self.runtime_config.get_xz_options()
}
)
result = image_builder.create()
result.print_results()
result.dump(
os.sep.join([abs_target_dir_path, 'kiwi.result'])
)
def create_initrd(self, mbrid=None, basename=None, install_initrd=False):
"""
Create initrd from prepared boot system tree and compress the result
:param object mbrid: instance of ImageIdentifier
:param string basename: base initrd file name
:param bool install_initrd: installation media initrd
"""
if self.is_prepared():
log.info('Creating initrd cpio archive')
# we can't simply exclude boot when building the archive
# because the file boot/mbrid must be preserved. Because of
# that we create a copy of the boot directory and remove
# everything in boot/ except for boot/mbrid. The original
# boot directory should not be changed because we rely
# on other data in boot/ e.g the kernel to be available
# for the entire image building process
if basename:
kiwi_initrd_basename = basename
else:
kiwi_initrd_basename = self.initrd_base_name
temp_boot_root_directory = mkdtemp(
prefix='kiwi_boot_root_copy.'
)
self.temp_directories.append(
temp_boot_root_directory
)
data = DataSync(
self.boot_root_directory + '/',
temp_boot_root_directory
)
data.sync_data(
options=['-z', '-a']
)
boot_directory = temp_boot_root_directory + '/boot'
Path.wipe(boot_directory)
if mbrid:
log.info(
'--> Importing mbrid: %s', mbrid.get_id()
)
Path.create(boot_directory)
image_identifier = boot_directory + '/mbrid'
mbrid.write(image_identifier)
cpio = ArchiveCpio(
os.sep.join([self.target_dir, kiwi_initrd_basename])
)
# the following is a list of directories which were needed
# during the process of creating an image but not when the
# image is actually booting with this initrd
exclude_from_archive = [
'/' + Defaults.get_shared_cache_location(),
'/image', '/usr/lib/grub*'
]
# the following is a list of directories to exclude which
# are not needed inside of the initrd
exclude_from_archive += [
'/usr/share/doc', '/usr/share/man', '/home', '/media', '/srv'
]
cpio.create(
source_dir=temp_boot_root_directory,
exclude=exclude_from_archive
)
log.info(
'--> xz compressing archive'
)
compress = Compress(
os.sep.join([self.target_dir, kiwi_initrd_basename])
)
compress.xz(
['--check=crc32', '--lzma2=dict=1MiB', '--threads=0']
)
self.initrd_filename = compress.compressed_filename
def _write_generic_fstab_to_boot_image(self, device_map):
if self.initrd_system == 'kiwi':
log.info('Creating generic boot image etc/fstab')
self._write_generic_fstab(device_map, self.boot_image.setup)
def _build_and_map_disk_partitions(self, disksize_mbytes): # noqa: C901
self.disk.wipe()
disksize_used_mbytes = 0
if self.firmware.legacy_bios_mode():
log.info('--> creating EFI CSM(legacy bios) partition')
partition_mbsize = self.firmware.get_legacy_bios_partition_size()
self.disk.create_efi_csm_partition(partition_mbsize)
disksize_used_mbytes += partition_mbsize
if self.firmware.efi_mode():
log.info('--> creating EFI partition')
partition_mbsize = self.firmware.get_efi_partition_size()
self.disk.create_efi_partition(partition_mbsize)
disksize_used_mbytes += partition_mbsize
if self.firmware.ofw_mode():
log.info('--> creating PReP partition')
partition_mbsize = self.firmware.get_prep_partition_size()
self.disk.create_prep_partition(partition_mbsize)
disksize_used_mbytes += partition_mbsize
if self.disk_setup.need_boot_partition():
log.info('--> creating boot partition')
partition_mbsize = self.disk_setup.boot_partition_size()
self.disk.create_boot_partition(partition_mbsize)
disksize_used_mbytes += partition_mbsize
if self.spare_part_mbsize and not self.spare_part_is_last:
log.info('--> creating spare partition')
self.disk.create_spare_partition(self.spare_part_mbsize)
if self.root_filesystem_is_overlay:
log.info('--> creating readonly root partition')
squashed_root_file = NamedTemporaryFile()
squashed_root = FileSystemSquashFs(device_provider=None,
root_dir=self.root_dir)
squashed_root.create_on_file(
filename=squashed_root_file.name,
exclude=[Defaults.get_shared_cache_location()])
squashed_rootfs_mbsize = int(
os.path.getsize(squashed_root_file.name) /
1048576) + Defaults.get_min_partition_mbytes()
self.disk.create_root_readonly_partition(squashed_rootfs_mbsize)
disksize_used_mbytes += squashed_rootfs_mbsize
if self.spare_part_mbsize and self.spare_part_is_last:
rootfs_mbsize = disksize_mbytes - disksize_used_mbytes - \
self.spare_part_mbsize - Defaults.get_min_partition_mbytes()
else:
rootfs_mbsize = 'all_free'
if self.volume_manager_name and self.volume_manager_name == 'lvm':
log.info('--> creating LVM root partition')
self.disk.create_root_lvm_partition(rootfs_mbsize)
elif self.mdraid:
log.info('--> creating mdraid root partition')
self.disk.create_root_raid_partition(rootfs_mbsize)
else:
log.info('--> creating root partition')
self.disk.create_root_partition(rootfs_mbsize)
if self.spare_part_mbsize and self.spare_part_is_last:
log.info('--> creating spare partition')
self.disk.create_spare_partition('all_free')
if self.firmware.bios_mode():
log.info('--> setting active flag to primary boot partition')
self.disk.activate_boot_partition()
if self.firmware.ofw_mode():
log.info('--> setting active flag to primary PReP partition')
self.disk.activate_boot_partition()
if self.firmware.efi_mode():
if self.force_mbr:
log.info('--> converting partition table to MBR')
self.disk.create_mbr()
elif self.hybrid_mbr:
log.info('--> converting partition table to hybrid GPT/MBR')
self.disk.create_hybrid_mbr()
self.disk.map_partitions()
return self.disk.get_device()
def install(self):
"""
Install bootloader on disk device
"""
log.info('Installing grub2 on disk %s', self.device)
if self.target_removable:
self.install_arguments.append('--removable')
if self.arch == 'x86_64' or self.arch == 'i686' or self.arch == 'i586':
self.target = 'i386-pc'
self.install_device = self.device
self.modules = ' '.join(
Defaults.get_grub_bios_modules(multiboot=True))
self.install_arguments.append('--skip-fs-probe')
elif self.arch.startswith('ppc64'):
if not self.custom_args or 'prep_device' not in self.custom_args:
raise KiwiBootLoaderGrubInstallError(
'prep device name required for grub2 installation on ppc')
self.target = 'powerpc-ieee1275'
self.install_device = self.custom_args['prep_device']
self.modules = ' '.join(Defaults.get_grub_ofw_modules())
self.install_arguments.append('--skip-fs-probe')
self.install_arguments.append('--no-nvram')
else:
raise KiwiBootLoaderGrubPlatformError(
'host architecture %s not supported for grub2 installation' %
self.arch)
self.root_mount = MountManager(device=self.custom_args['root_device'])
self.boot_mount = MountManager(device=self.custom_args['boot_device'],
mountpoint=self.root_mount.mountpoint +
'/boot')
self.root_mount.mount()
if not self.root_mount.device == self.boot_mount.device:
self.boot_mount.mount()
if self.volumes:
for volume_path in Path.sort_by_hierarchy(
sorted(self.volumes.keys())):
volume_mount = MountManager(
device=self.volumes[volume_path]['volume_device'],
mountpoint=self.root_mount.mountpoint + '/' + volume_path)
self.volumes_mount.append(volume_mount)
volume_mount.mount(
options=[self.volumes[volume_path]['volume_options']])
self.device_mount = MountManager(
device='/dev', mountpoint=self.root_mount.mountpoint + '/dev')
self.proc_mount = MountManager(device='/proc',
mountpoint=self.root_mount.mountpoint +
'/proc')
self.sysfs_mount = MountManager(device='/sys',
mountpoint=self.root_mount.mountpoint +
'/sys')
self.device_mount.bind_mount()
self.proc_mount.bind_mount()
self.sysfs_mount.bind_mount()
# check if a grub installation could be found in the image system
grub_directory = Defaults.get_grub_path(self.root_mount.mountpoint +
'/usr/lib')
if not grub_directory:
raise KiwiBootLoaderGrubDataError(
'No grub2 installation found in %s' %
self.root_mount.mountpoint)
grub_directory = grub_directory.replace(self.root_mount.mountpoint, '')
module_directory = grub_directory + '/' + self.target
boot_directory = '/boot'
# wipe existing grubenv to allow the grub installer to create a new one
grubenv_glob = os.sep.join(
[self.root_mount.mountpoint, 'boot', '*', 'grubenv'])
for grubenv in glob.glob(grubenv_glob):
Path.wipe(grubenv)
# install grub2 boot code
Command.run([
'chroot', self.root_mount.mountpoint,
self._get_grub2_install_tool_name(self.root_mount.mountpoint)
] + self.install_arguments + [
'--directory', module_directory, '--boot-directory',
boot_directory, '--target', self.target, '--modules', self.modules,
self.install_device
])
if self.firmware and self.firmware.efi_mode() == 'uefi':
shim_install = self._get_shim_install_tool_name(
self.root_mount.mountpoint)
# if shim-install does _not_ exist the fallback mechanism
# has applied at the bootloader/config level and we expect
# no further tool calls to be required
if shim_install:
self.efi_mount = MountManager(
device=self.custom_args['efi_device'],
mountpoint=self.root_mount.mountpoint + '/boot/efi')
self.efi_mount.mount()
# Before we call shim-install, the grub installer binary is
# replaced by a noop. Actually there is no reason for
# shim-install to call the grub installer because it should
# only setup the system for EFI secure boot which does not
# require any bootloader code in the master boot record.
# In addition kiwi has called the grub installer right
# before
self._disable_grub2_install(self.root_mount.mountpoint)
Command.run([
'chroot', self.root_mount.mountpoint, 'shim-install',
'--removable', self.install_device
])
# restore the grub installer noop
self._enable_grub2_install(self.root_mount.mountpoint)
def create_recovery_archive(self):
"""
Create a compressed recovery archive from the root tree
for use with kiwi's recvoery system. The method creates
additional data into the image root filesystem which is
deleted prior to the creation of a new recovery data set
"""
# cleanup
bash_comand = ['rm', '-f', self.root_dir + '/recovery.*']
Command.run(['bash', '-c', ' '.join(bash_comand)])
if not self.oemconfig['recovery']:
return
# recovery.tar
log.info('Creating recovery tar archive')
metadata = {
'archive_name': self.root_dir + '/recovery.tar',
'archive_filecount': self.root_dir + '/recovery.tar.files',
'archive_size': self.root_dir + '/recovery.tar.size',
'partition_size': self.root_dir + '/recovery.partition.size',
'partition_filesystem': self.root_dir + '/recovery.tar.filesystem'
}
recovery_archive = NamedTemporaryFile(delete=False)
archive = ArchiveTar(filename=recovery_archive.name,
create_from_file_list=False)
archive.create(source_dir=self.root_dir,
exclude=['dev', 'proc', 'sys'],
options=[
'--numeric-owner', '--hard-dereference',
'--preserve-permissions'
])
Command.run(['mv', recovery_archive.name, metadata['archive_name']])
# recovery.tar.filesystem
recovery_filesystem = self.xml_state.build_type.get_filesystem()
with open(metadata['partition_filesystem'], 'w') as partfs:
partfs.write('%s' % recovery_filesystem)
log.info('--> Recovery partition filesystem: %s', recovery_filesystem)
# recovery.tar.files
bash_comand = ['tar', '-tf', metadata['archive_name'], '|', 'wc', '-l']
tar_files_call = Command.run(['bash', '-c', ' '.join(bash_comand)])
tar_files_count = int(tar_files_call.output.rstrip('\n'))
with open(metadata['archive_filecount'], 'w') as files:
files.write('%d\n' % tar_files_count)
log.info('--> Recovery file count: %d files', tar_files_count)
# recovery.tar.size
recovery_archive_size_bytes = os.path.getsize(metadata['archive_name'])
with open(metadata['archive_size'], 'w') as size:
size.write('%d' % recovery_archive_size_bytes)
log.info('--> Recovery uncompressed size: %d mbytes',
int(recovery_archive_size_bytes / 1048576))
# recovery.tar.gz
log.info('--> Compressing recovery archive')
compress = Compress(self.root_dir + '/recovery.tar')
compress.gzip()
# recovery.partition.size
recovery_archive_gz_size_mbytes = int(
os.path.getsize(metadata['archive_name'] + '.gz') / 1048576)
recovery_partition_mbytes = recovery_archive_gz_size_mbytes \
+ Defaults.get_recovery_spare_mbytes()
with open(metadata['partition_size'], 'w') as gzsize:
gzsize.write('%d' % recovery_partition_mbytes)
log.info('--> Recovery partition size: %d mbytes',
recovery_partition_mbytes)
# delete recovery archive if inplace recovery is requested
# In this mode the recovery archive is created at install time
# and not at image creation time. However the recovery metadata
# is preserved in order to be able to check if enough space
# is available on the disk to create the recovery archive.
if self.oemconfig['recovery_inplace']:
log.info('--> Inplace recovery requested, deleting archive')
Path.wipe(metadata['archive_name'] + '.gz')
def __del__(self):
if self.temp_image_dir and os.path.exists(self.temp_image_dir):
log.info('Cleaning up %s instance', type(self).__name__)
Path.wipe(self.temp_image_dir)
def create(self):
"""
Build a pxe image set consisting out of a boot image(initrd)
plus its appropriate kernel files and the root filesystem
image with a checksum. The result can be used within the kiwi
PXE boot infrastructure
Image types which triggers this builder are:
* image="pxe"
"""
log.info('Creating PXE root filesystem image')
self.filesystem.create()
os.rename(self.filesystem.filename, self.image_name)
self.image = self.image_name
if self.compressed:
log.info('xz compressing root filesystem image')
compress = Compress(self.image)
compress.xz(self.xz_options)
self.image = compress.compressed_filename
log.info('Creating PXE root filesystem MD5 checksum')
self.filesystem_checksum = ''.join([self.image, '.md5'])
checksum = Checksum(self.image)
checksum.md5(self.filesystem_checksum)
# prepare boot(initrd) root system
log.info('Creating PXE boot image')
self.boot_image_task.prepare()
# export modprobe configuration to boot image
self.system_setup.export_modprobe_setup(
self.boot_image_task.boot_root_directory)
# extract kernel from boot(initrd) root system
kernel = Kernel(self.boot_image_task.boot_root_directory)
kernel_data = kernel.get_kernel()
if kernel_data:
self.kernel_filename = ''.join([
os.path.basename(self.image_name), '-', kernel_data.version,
'.kernel'
])
kernel.copy_kernel(self.target_dir, self.kernel_filename)
else:
raise KiwiPxeBootImageError(
'No kernel in boot image tree %s found' %
self.boot_image_task.boot_root_directory)
# extract hypervisor from boot(initrd) root system
if self.xen_server:
kernel_data = kernel.get_xen_hypervisor()
if kernel_data:
self.hypervisor_filename = ''.join(
[os.path.basename(self.image_name), '-', kernel_data.name])
kernel.copy_xen_hypervisor(self.target_dir,
self.hypervisor_filename)
self.result.add(key='xen_hypervisor',
filename=self.target_dir + '/' +
self.hypervisor_filename,
use_for_bundle=True,
compress=False,
shasum=True)
else:
raise KiwiPxeBootImageError(
'No hypervisor in boot image tree %s found' %
self.boot_image_task.boot_root_directory)
# create initrd for pxe boot
self.boot_image_task.create_initrd()
# put results into a tarball
Command.run([
'tar', '-C', self.target_dir, '-cJf', self.archive_name,
self.kernel_filename,
os.path.basename(self.boot_image_task.initrd_filename),
os.path.basename(self.image),
os.path.basename(self.filesystem_checksum)
])
# store results
self.result.add(key='pxe_archive',
filename=self.archive_name,
use_for_bundle=True,
compress=False,
shasum=True)
# create image root metadata
self.result.add(key='image_packages',
filename=self.system_setup.export_rpm_package_list(
self.target_dir),
use_for_bundle=True,
compress=False,
shasum=False)
self.result.add(
key='image_verified',
filename=self.system_setup.export_rpm_package_verification(
self.target_dir),
use_for_bundle=True,
compress=False,
shasum=False)
if self.pxedeploy:
log.warning(
'Creation of client config file from pxedeploy not implemented'
)
return self.result
def process(self):
"""
Create result bundle from the image build results in the
specified target directory. Each result image will contain
the specified bundle identifier as part of its filename.
Uncompressed image files will also become xz compressed
and a sha sum will be created from every result image
"""
self.manual = Help()
if self._help():
return
# load serialized result object from target directory
result_directory = os.path.abspath(self.command_args['--target-dir'])
bundle_directory = os.path.abspath(self.command_args['--bundle-dir'])
if result_directory == bundle_directory:
raise KiwiBundleError(
'Bundle directory must be different from target directory')
log.info('Bundle build results from %s', result_directory)
result = Result.load(result_directory + '/kiwi.result')
image_version = result.xml_state.get_image_version()
ordered_results = OrderedDict(sorted(result.get_results().items()))
# hard link bundle files, compress and build checksum
if not os.path.exists(bundle_directory):
Path.create(bundle_directory)
for result_file in list(ordered_results.values()):
if result_file.use_for_bundle:
bundle_file_basename = os.path.basename(result_file.filename)
# The bundle id is only taken into account for image results
# which contains the image version in its nane
bundle_file_basename = bundle_file_basename.replace(
image_version,
image_version + '-' + self.command_args['--id'])
log.info('Creating %s', bundle_file_basename)
bundle_file = ''.join(
[bundle_directory, '/', bundle_file_basename])
checksum_file = ''.join(
[bundle_directory, '/', bundle_file_basename, '.sha256'])
Command.run(['cp', result_file.filename, bundle_file])
if result_file.compress:
log.info('--> XZ compressing')
compress = Compress(bundle_file)
compress.xz(self.runtime_config.get_xz_options())
bundle_file = compress.compressed_filename
checksum_file = compress.compressed_filename + '.sha256'
if self.command_args['--zsync-source']:
zsyncmake = Path.which('zsyncmake',
access_mode=os.X_OK)
if zsyncmake:
log.info('--> Creating zsync control file')
Command.run([
zsyncmake, '-e', '-u',
os.sep.join([
self.command_args['--zsync-source'],
os.path.basename(bundle_file)
]), '-o', bundle_file + '.zsync', bundle_file
])
else:
log.warning(
'--> zsyncmake missing, zsync setup skipped')
if result_file.shasum:
log.info('--> Creating SHA 256 sum')
checksum = Checksum(bundle_file)
with open(checksum_file, 'w') as shasum:
shasum.write(checksum.sha256())
def create(self):
"""
Build a bootable hybrid live ISO image
Image types which triggers this builder are:
* image="iso"
:raises KiwiLiveBootImageError: if no kernel or hipervisor is found
in boot image tree
:return: result
:rtype: instance of :class:`Result`
"""
# media dir to store CD contents
self.media_dir = mkdtemp(prefix='live-media.', dir=self.target_dir)
# unpack cdroot user files to media dir
self.system_setup.import_cdroot_files(self.media_dir)
rootsize = SystemSize(self.media_dir)
# custom iso metadata
log.info('Using following live ISO metadata:')
log.info('--> Application id: {0}'.format(self.mbrid.get_id()))
log.info('--> Publisher: {0}'.format(Defaults.get_publisher()))
log.info('--> Volume id: {0}'.format(self.volume_id))
custom_iso_args = {
'meta_data': {
'publisher': self.publisher,
'preparer': Defaults.get_preparer(),
'volume_id': self.volume_id,
'mbr_id': self.mbrid.get_id(),
'efi_mode': self.firmware.efi_mode()
}
}
log.info('Setting up live image bootloader configuration')
if self.firmware.efi_mode():
# setup bootloader config to boot the ISO via EFI
# This also embedds an MBR and the respective BIOS modules
# for compat boot. The complete bootloader setup will be
# based on grub
bootloader_config = BootLoaderConfig(
'grub2',
self.xml_state,
root_dir=self.root_dir,
boot_dir=self.media_dir,
custom_args={
'grub_directory_name':
Defaults.get_grub_boot_directory_name(self.root_dir)
})
bootloader_config.setup_live_boot_images(mbrid=self.mbrid,
lookup_path=self.root_dir)
else:
# setup bootloader config to boot the ISO via isolinux.
# This allows for booting on x86 platforms in BIOS mode
# only.
bootloader_config = BootLoaderConfig('isolinux',
self.xml_state,
root_dir=self.root_dir,
boot_dir=self.media_dir)
IsoToolsBase.setup_media_loader_directory(
self.boot_image.boot_root_directory, self.media_dir,
bootloader_config.get_boot_theme())
bootloader_config.write_meta_data(iso_boot=True)
bootloader_config.setup_live_image_config(mbrid=self.mbrid)
bootloader_config.write()
# call custom editbootconfig script if present
self.system_setup.call_edit_boot_config_script(
filesystem='iso:{0}'.format(self.media_dir),
boot_part_id=1,
working_directory=self.root_dir)
# prepare dracut initrd call
self.boot_image.prepare()
# create dracut initrd for live image
log.info('Creating live ISO boot image')
live_dracut_module = Defaults.get_live_dracut_module_from_flag(
self.live_type)
self.boot_image.include_module('pollcdrom')
self.boot_image.include_module(live_dracut_module)
self.boot_image.omit_module('multipath')
self.boot_image.write_system_config_file(
config={
'modules': ['pollcdrom', live_dracut_module],
'omit_modules': ['multipath']
},
config_file=self.root_dir + '/etc/dracut.conf.d/02-livecd.conf')
self.boot_image.create_initrd(self.mbrid)
# setup kernel file(s) and initrd in ISO boot layout
log.info('Setting up kernel file(s) and boot image in ISO boot layout')
self._setup_live_iso_kernel_and_initrd()
# calculate size and decide if we need UDF
if rootsize.accumulate_mbyte_file_sizes() > 4096:
log.info('ISO exceeds 4G size, using UDF filesystem')
custom_iso_args['meta_data']['udf'] = True
# pack system into live boot structure as expected by dracut
log.info('Packing system into dracut live ISO type: {0}'.format(
self.live_type))
root_filesystem = Defaults.get_default_live_iso_root_filesystem()
filesystem_custom_parameters = {
'mount_options': self.xml_state.get_fs_mount_option_list(),
'create_options': self.xml_state.get_fs_create_option_list()
}
filesystem_setup = FileSystemSetup(self.xml_state, self.root_dir)
root_image = NamedTemporaryFile()
loop_provider = LoopDevice(
root_image.name, filesystem_setup.get_size_mbytes(root_filesystem),
self.xml_state.build_type.get_target_blocksize())
loop_provider.create()
live_filesystem = FileSystem(name=root_filesystem,
device_provider=loop_provider,
root_dir=self.root_dir + os.sep,
custom_args=filesystem_custom_parameters)
live_filesystem.create_on_device()
log.info('--> Syncing data to {0} root image'.format(root_filesystem))
live_filesystem.sync_data(
Defaults.get_exclude_list_for_root_data_sync())
log.info('--> Creating squashfs container for root image')
self.live_container_dir = mkdtemp(prefix='live-container.',
dir=self.target_dir)
Path.create(self.live_container_dir + '/LiveOS')
shutil.copy(root_image.name,
self.live_container_dir + '/LiveOS/rootfs.img')
live_container_image = FileSystem(name='squashfs',
device_provider=None,
root_dir=self.live_container_dir)
container_image = NamedTemporaryFile()
live_container_image.create_on_file(container_image.name)
Path.create(self.media_dir + '/LiveOS')
shutil.copy(container_image.name,
self.media_dir + '/LiveOS/squashfs.img')
# create iso filesystem from media_dir
log.info('Creating live ISO image')
iso_image = FileSystemIsoFs(device_provider=None,
root_dir=self.media_dir,
custom_args=custom_iso_args)
iso_image.create_on_file(self.isoname)
# include metadata for checkmedia tool
if self.xml_state.build_type.get_mediacheck() is True:
Iso.set_media_tag(self.isoname)
self.result.verify_image_size(
self.runtime_config.get_max_size_constraint(), self.isoname)
self.result.add(key='live_image',
filename=self.isoname,
use_for_bundle=True,
compress=False,
shasum=True)
self.result.add(key='image_packages',
filename=self.system_setup.export_package_list(
self.target_dir),
use_for_bundle=True,
compress=False,
shasum=False)
self.result.add(key='image_verified',
filename=self.system_setup.export_package_verification(
self.target_dir),
use_for_bundle=True,
compress=False,
shasum=False)
return self.result
def process(self): # noqa: C901
"""
Prepare and install a new system for chroot access
"""
self.manual = Help()
if self._help():
return
Privileges.check_for_root_permissions()
self.load_xml_description(self.command_args['--description'])
abs_root_path = os.path.abspath(self.command_args['--root'])
self.runtime_checker.check_efi_mode_for_disk_overlay_correctly_setup()
self.runtime_checker.check_grub_efi_installed_for_efi_firmware()
self.runtime_checker.check_boot_description_exists()
self.runtime_checker.check_consistent_kernel_in_boot_and_system_image()
self.runtime_checker.check_docker_tool_chain_installed()
self.runtime_checker.check_volume_setup_has_no_root_definition()
self.runtime_checker.check_xen_uniquely_setup_as_server_or_guest()
self.runtime_checker.check_target_directory_not_in_shared_cache(
abs_root_path)
self.runtime_checker.check_mediacheck_only_for_x86_arch()
self.runtime_checker.check_dracut_module_for_live_iso_in_package_list()
self.runtime_checker.check_dracut_module_for_disk_overlay_in_package_list(
)
self.runtime_checker.check_dracut_module_for_disk_oem_in_package_list()
self.runtime_checker.check_dracut_module_for_oem_install_in_package_list(
)
if self.command_args['--ignore-repos']:
self.xml_state.delete_repository_sections()
elif self.command_args['--ignore-repos-used-for-build']:
self.xml_state.delete_repository_sections_used_for_build()
if self.command_args['--set-repo']:
self.xml_state.set_repository(
*self.sextuple_token(self.command_args['--set-repo']))
if self.command_args['--add-repo']:
for add_repo in self.command_args['--add-repo']:
self.xml_state.add_repository(*self.sextuple_token(add_repo))
if self.command_args['--set-container-tag']:
self.xml_state.set_container_config_tag(
self.command_args['--set-container-tag'])
if self.command_args['--set-container-derived-from']:
self.xml_state.set_derived_from_image_uri(
self.command_args['--set-container-derived-from'])
self.runtime_checker.check_repositories_configured()
self.runtime_checker.check_image_include_repos_publicly_resolvable()
package_requests = False
if self.command_args['--add-package']:
package_requests = True
if self.command_args['--delete-package']:
package_requests = True
log.info('Preparing system')
system = SystemPrepare(self.xml_state, abs_root_path,
self.command_args['--allow-existing-root'])
manager = system.setup_repositories(self.command_args['--clear-cache'],
self.command_args['--signing-key'])
system.install_bootstrap(manager)
system.install_system(manager)
if package_requests:
if self.command_args['--add-package']:
system.install_packages(manager,
self.command_args['--add-package'])
if self.command_args['--delete-package']:
system.delete_packages(manager,
self.command_args['--delete-package'])
profile = Profile(self.xml_state)
defaults = Defaults()
defaults.to_profile(profile)
setup = SystemSetup(self.xml_state, abs_root_path)
setup.import_shell_environment(profile)
setup.import_description()
setup.import_overlay_files()
setup.import_image_identifier()
setup.setup_groups()
setup.setup_users()
setup.setup_keyboard_map()
setup.setup_locale()
setup.setup_plymouth_splash()
setup.setup_timezone()
system.pinch_system(manager=manager, force=True)
# make sure manager instance is cleaned up now
del manager
# setup permanent image repositories after cleanup
setup.import_repositories_marked_as_imageinclude()
setup.call_config_script()
# make sure system instance is cleaned up now
del system
def create_install_pxe_archive(self):
"""
Create an oem install tar archive suitable for installing a
disk image via the network using the PXE boot protocol.
The archive contains:
* The raw system image xz compressed
* The raw system image checksum metadata file
* The append file template for the boot server
* The system image initrd for kexec
* The install initrd
* The kernel
Image types which triggers this builder are:
* installpxe="true|false"
"""
self.pxe_dir = mkdtemp(prefix='kiwi_pxe_install_media.',
dir=self.target_dir)
# the system image is transfered as xz compressed variant
log.info('xz compressing disk image')
pxe_image_filename = ''.join(
[self.pxe_dir, '/',
self.xml_state.xml_data.get_name(), '.xz'])
compress = Compress(source_filename=self.diskname,
keep_source_on_compress=True)
compress.xz(self.xz_options)
Command.run(['mv', compress.compressed_filename, pxe_image_filename])
# the system image transfer is checked against a checksum
log.info('Creating disk image checksum')
pxe_md5_filename = ''.join(
[self.pxe_dir, '/',
self.xml_state.xml_data.get_name(), '.md5'])
checksum = Checksum(self.diskname)
checksum.md5(pxe_md5_filename)
# the install image name is stored in a config file
if self.initrd_system == 'kiwi':
self._write_install_image_info_to_boot_image()
# the kexec required system image initrd is stored for dracut kiwi-dump
if self.initrd_system == 'dracut':
boot_names = self.boot_image_task.get_boot_names()
system_image_initrd = os.sep.join(
[self.root_dir, 'boot', boot_names.initrd_name])
target_initrd_name = '{0}/{1}.initrd'.format(
self.pxe_dir, self.xml_state.xml_data.get_name())
shutil.copy(system_image_initrd, target_initrd_name)
os.chmod(target_initrd_name, 420)
# create pxe config append information
# this information helps to configure the boot server correctly
append_filename = ''.join(
[self.pxe_dir, '/',
self.xml_state.xml_data.get_name(), '.append'])
if self.initrd_system == 'kiwi':
cmdline = 'pxe=1'
else:
cmdline = ' '.join([
'rd.kiwi.install.pxe',
'rd.kiwi.install.image=http://example.com/image.xz'
])
custom_cmdline = self.xml_state.build_type.get_kernelcmdline()
if custom_cmdline:
cmdline += ' ' + custom_cmdline
with open(append_filename, 'w') as append:
append.write('%s\n' % cmdline)
# create initrd for pxe install
log.info('Creating pxe install boot image')
self._create_pxe_install_kernel_and_initrd()
# create pxe install tarball
log.info('Creating pxe install archive')
archive = ArchiveTar(self.pxename)
archive.create(self.pxe_dir)
def create_disk(self): # noqa: C901
"""
Build a bootable raw disk image
:raises KiwiInstallMediaError:
if install media is required and image type is not oem
:raises KiwiVolumeManagerSetupError:
root overlay at the same time volumes are defined is not supported
:return: result
:rtype: instance of :class:`Result`
"""
if self.install_media and self.build_type_name != 'oem':
raise KiwiInstallMediaError(
'Install media requires oem type setup, got %s' %
self.build_type_name)
if self.root_filesystem_is_overlay and self.volume_manager_name:
raise KiwiVolumeManagerSetupError(
'Volume management together with root overlay is not supported'
)
# setup recovery archive, cleanup and create archive if requested
self.system_setup.create_recovery_archive()
# prepare boot(initrd) root system
log.info('Preparing boot system')
self.boot_image.prepare()
# precalculate needed disk size
disksize_mbytes = self.disk_setup.get_disksize_mbytes()
# create the disk
log.info('Creating raw disk image %s', self.diskname)
loop_provider = LoopDevice(self.diskname, disksize_mbytes,
self.blocksize)
loop_provider.create()
self.disk = Disk(self.firmware.get_partition_table_type(),
loop_provider, self.xml_state.get_disk_start_sector())
# create the bootloader instance
self.bootloader_config = BootLoaderConfig(
self.bootloader,
self.xml_state,
root_dir=self.root_dir,
boot_dir=self.root_dir,
custom_args={
'targetbase':
loop_provider.get_device(),
'grub_directory_name':
Defaults.get_grub_boot_directory_name(self.root_dir),
'boot_is_crypto':
self.boot_is_crypto
})
# create disk partitions and instance device map
device_map = self._build_and_map_disk_partitions(disksize_mbytes)
# create raid on current root device if requested
if self.mdraid:
self.raid_root = RaidDevice(device_map['root'])
self.raid_root.create_degraded_raid(raid_level=self.mdraid)
device_map['root'] = self.raid_root.get_device()
self.disk.public_partition_id_map['kiwi_RaidPart'] = \
self.disk.public_partition_id_map['kiwi_RootPart']
self.disk.public_partition_id_map['kiwi_RaidDev'] = \
device_map['root'].get_device()
# create luks on current root device if requested
if self.luks:
self.luks_root = LuksDevice(device_map['root'])
self.luks_boot_keyfile = ''.join([self.root_dir, '/.root.keyfile'])
self.luks_root.create_crypto_luks(passphrase=self.luks,
os=self.luks_os,
keyfile=self.luks_boot_keyfile
if self.boot_is_crypto else None)
if self.boot_is_crypto:
self.boot_image.include_file(
os.sep + os.path.basename(self.luks_boot_keyfile))
device_map['luks_root'] = device_map['root']
device_map['root'] = self.luks_root.get_device()
# create spare filesystem on spare partition if present
self._build_spare_filesystem(device_map)
# create filesystems on boot partition(s) if any
self._build_boot_filesystems(device_map)
# create volumes and filesystems for root system
if self.volume_manager_name:
volume_manager_custom_parameters = {
'fs_mount_options':
self.custom_root_mount_args,
'fs_create_options':
self.custom_root_creation_args,
'root_label':
self.disk_setup.get_root_label(),
'root_is_snapshot':
self.xml_state.build_type.get_btrfs_root_is_snapshot(),
'root_is_readonly_snapshot':
self.xml_state.build_type.get_btrfs_root_is_readonly_snapshot(
),
'quota_groups':
self.xml_state.build_type.get_btrfs_quota_groups(),
'image_type':
self.xml_state.get_build_type_name()
}
volume_manager = VolumeManager(self.volume_manager_name,
device_map['root'],
self.root_dir + '/', self.volumes,
volume_manager_custom_parameters)
volume_manager.setup(self.volume_group_name)
volume_manager.create_volumes(self.requested_filesystem)
volume_manager.mount_volumes()
self.generic_fstab_entries += volume_manager.get_fstab(
self.persistency_type, self.requested_filesystem)
self.system = volume_manager
device_map['root'] = volume_manager.get_device()['root']
else:
log.info('Creating root(%s) filesystem on %s',
self.requested_filesystem,
device_map['root'].get_device())
filesystem_custom_parameters = {
'mount_options': self.custom_root_mount_args,
'create_options': self.custom_root_creation_args
}
filesystem = FileSystem(self.requested_filesystem,
device_map['root'], self.root_dir + '/',
filesystem_custom_parameters)
filesystem.create_on_device(label=self.disk_setup.get_root_label())
self.system = filesystem
# create a random image identifier
self.mbrid = SystemIdentifier()
self.mbrid.calculate_id()
# create first stage metadata to boot image
self._write_partition_id_config_to_boot_image()
self._write_recovery_metadata_to_boot_image()
self._write_raid_config_to_boot_image()
self._write_generic_fstab_to_boot_image(device_map)
self.system_setup.export_modprobe_setup(
self.boot_image.boot_root_directory)
# create first stage metadata to system image
self._write_image_identifier_to_system_image()
self._write_crypttab_to_system_image()
self._write_generic_fstab_to_system_image(device_map)
if self.initrd_system == 'dracut':
self._create_dracut_config()
# create initrd cpio archive
self.boot_image.create_initrd(self.mbrid)
# create dracut config omitting one time kiwi dracut modules
if self.initrd_system == 'dracut':
self._create_system_dracut_config()
# create second stage metadata to system image
self._copy_first_boot_files_to_system_image()
self._write_bootloader_config_to_system_image(device_map)
self.mbrid.write_to_disk(self.disk.storage_provider)
# set SELinux file security contexts if context exists
self._setup_selinux_file_contexts()
# syncing system data to disk image
log.info('Syncing system to image')
if self.system_spare:
self.system_spare.sync_data()
if self.system_efi:
log.info('--> Syncing EFI boot data to EFI partition')
self.system_efi.sync_data()
if self.system_boot:
log.info('--> Syncing boot data at extra partition')
self.system_boot.sync_data(
self._get_exclude_list_for_boot_data_sync())
log.info('--> Syncing root filesystem data')
if self.root_filesystem_is_overlay:
squashed_root_file = NamedTemporaryFile()
squashed_root = FileSystemSquashFs(device_provider=None,
root_dir=self.root_dir)
squashed_root.create_on_file(
filename=squashed_root_file.name,
exclude=self._get_exclude_list_for_root_data_sync(device_map))
Command.run([
'dd',
'if=%s' % squashed_root_file.name,
'of=%s' % device_map['readonly'].get_device()
])
else:
self.system.sync_data(
self._get_exclude_list_for_root_data_sync(device_map))
# install boot loader
self._install_bootloader(device_map)
# set root filesystem properties
self._setup_property_root_is_readonly_snapshot()
# prepare for install media if requested
if self.install_media:
log.info('Saving boot image instance to file')
self.boot_image.dump(self.target_dir + '/boot_image.pickledump')
self.result.verify_image_size(
self.runtime_config.get_max_size_constraint(), self.diskname)
# store image file name in result
self.result.add(
key='disk_image',
filename=self.diskname,
use_for_bundle=True if not self.image_format else False,
compress=self.runtime_config.get_bundle_compression(default=True),
shasum=True)
# create image root metadata
self.result.add(key='image_packages',
filename=self.system_setup.export_package_list(
self.target_dir),
use_for_bundle=True,
compress=False,
shasum=False)
self.result.add(key='image_verified',
filename=self.system_setup.export_package_verification(
self.target_dir),
use_for_bundle=True,
compress=False,
shasum=False)
return self.result
def process(self):
"""
Build a system image from the specified description. The
build command combines the prepare and create commands
"""
self.manual = Help()
if self._help():
return
Privileges.check_for_root_permissions()
abs_target_dir_path = os.path.abspath(
self.command_args['--target-dir']
)
build_dir = os.sep.join([abs_target_dir_path, 'build'])
image_root = os.sep.join([build_dir, 'image-root'])
Path.create(build_dir)
if not self.global_args['--logfile']:
log.set_logfile(
os.sep.join([abs_target_dir_path, 'build', 'image-root.log'])
)
self.load_xml_description(
self.command_args['--description']
)
self.runtime_checker.check_consistent_kernel_in_boot_and_system_image()
self.runtime_checker.check_boot_image_reference_correctly_setup()
self.runtime_checker.check_docker_tool_chain_installed()
self.runtime_checker.check_volume_setup_has_no_root_definition()
self.runtime_checker.check_image_include_repos_http_resolvable()
self.runtime_checker.check_target_directory_not_in_shared_cache(
abs_target_dir_path
)
if self.command_args['--ignore-repos']:
self.xml_state.delete_repository_sections()
if self.command_args['--set-repo']:
(repo_source, repo_type, repo_alias, repo_prio) = \
self.quadruple_token(self.command_args['--set-repo'])
self.xml_state.set_repository(
repo_source, repo_type, repo_alias, repo_prio
)
if self.command_args['--add-repo']:
for add_repo in self.command_args['--add-repo']:
(repo_source, repo_type, repo_alias, repo_prio) = \
self.quadruple_token(add_repo)
self.xml_state.add_repository(
repo_source, repo_type, repo_alias, repo_prio
)
Path.create(abs_target_dir_path)
if self.command_args['--set-container-tag']:
self.xml_state.set_container_config_tag(
self.command_args['--set-container-tag']
)
if self.command_args['--set-container-derived-from']:
self.xml_state.set_derived_from_image_uri(
self.command_args['--set-container-derived-from']
)
self.runtime_checker.check_repositories_configured()
if Defaults.is_obs_worker():
# This build runs inside of a buildservice worker. Therefore
# the repo defintions is adapted accordingly
self.xml_state.translate_obs_to_suse_repositories()
elif self.command_args['--obs-repo-internal']:
# This build should use the internal SUSE buildservice
# Be aware that the buildhost has to provide access
self.xml_state.translate_obs_to_ibs_repositories()
package_requests = False
if self.command_args['--add-package']:
package_requests = True
if self.command_args['--delete-package']:
package_requests = True
log.info('Preparing new root system')
system = SystemPrepare(
self.xml_state,
image_root,
self.command_args['--allow-existing-root']
)
manager = system.setup_repositories(
self.command_args['--clear-cache'],
self.command_args['--signing-key']
)
system.install_bootstrap(manager)
system.install_system(
manager
)
if package_requests:
if self.command_args['--add-package']:
system.install_packages(
manager, self.command_args['--add-package']
)
if self.command_args['--delete-package']:
system.delete_packages(
manager, self.command_args['--delete-package']
)
profile = Profile(self.xml_state)
defaults = Defaults()
defaults.to_profile(profile)
setup = SystemSetup(
self.xml_state, image_root
)
setup.import_shell_environment(profile)
setup.import_description()
setup.import_overlay_files()
setup.import_image_identifier()
setup.setup_groups()
setup.setup_users()
setup.setup_keyboard_map()
setup.setup_locale()
setup.setup_timezone()
system.pinch_system(
manager=manager, force=True
)
# make sure manager instance is cleaned up now
del manager
# setup permanent image repositories after cleanup
if self.xml_state.has_repositories_marked_as_imageinclude():
setup.import_repositories_marked_as_imageinclude()
setup.call_config_script()
# make sure system instance is cleaned up now
del system
setup.call_image_script()
# make sure setup instance is cleaned up now
del setup
log.info('Creating system image')
image_builder = ImageBuilder(
self.xml_state,
abs_target_dir_path,
image_root,
{'signing_keys': self.command_args['--signing-key']}
)
result = image_builder.create()
result.print_results()
result.dump(
os.sep.join([abs_target_dir_path, 'kiwi.result'])
)
def _write_generic_fstab_to_system_image(self, device_map):
log.info('Creating generic system etc/fstab')
self._write_generic_fstab(device_map, self.system_setup)
def __del__(self):
log.info('Cleaning up %s instance', type(self).__name__)
try:
self.root_bind.cleanup()
except Exception:
pass
def _write_image_identifier_to_system_image(self):
log.info('Creating image identifier: %s', self.mbrid.get_id())
self.mbrid.write(self.root_dir + '/boot/mbrid')
def create(self):
"""
Builds a container image which is usually a tarball including
container specific metadata.
Image types which triggers this builder are:
* image="docker"
"""
if not self.base_image:
log.info(
'Setting up %s container', self.requested_container_type
)
container_setup = ContainerSetup(
self.requested_container_type, self.root_dir,
self.container_config
)
container_setup.setup()
else:
checksum = Checksum(self.base_image)
if not checksum.matches(checksum.md5(), self.base_image_md5):
raise KiwiContainerBuilderError(
'base image file {0} checksum validation failed'.format(
self.base_image
)
)
log.info(
'--> Creating container image'
)
container_image = ContainerImage(
self.requested_container_type, self.root_dir, self.container_config
)
container_image.create(
self.filename, self.base_image
)
self.result.add(
key='container',
filename=self.filename,
use_for_bundle=True,
compress=False,
shasum=True
)
self.result.add(
key='image_packages',
filename=self.system_setup.export_rpm_package_list(
self.target_dir
),
use_for_bundle=True,
compress=False,
shasum=False
)
self.result.add(
key='image_verified',
filename=self.system_setup.export_rpm_package_verification(
self.target_dir
),
use_for_bundle=True,
compress=False,
shasum=False
)
return self.result
def setup_repositories(self, clear_cache=False, signing_keys=None):
"""
Set up repositories for software installation and return a
package manager for performing software installation tasks
:return: Instance of PackageManager
:rtype: PackageManager
"""
repository_options = []
repository_sections = \
self.xml_state.get_repository_sections_used_for_build()
package_manager = self.xml_state.get_package_manager()
if self.xml_state.get_rpm_check_signatures():
repository_options.append('check_signatures')
if self.xml_state.get_rpm_excludedocs():
repository_options.append('exclude_docs')
repo = Repository(
self.root_bind, package_manager, repository_options
)
if signing_keys:
repo.import_trusted_keys(signing_keys)
for xml_repo in repository_sections:
repo_type = xml_repo.get_type()
repo_source = xml_repo.get_source().get_path()
repo_user = xml_repo.get_username()
repo_secret = xml_repo.get_password()
repo_alias = xml_repo.get_alias()
repo_priority = xml_repo.get_priority()
repo_dist = xml_repo.get_distribution()
repo_components = xml_repo.get_components()
repo_repository_gpgcheck = xml_repo.get_repository_gpgcheck()
repo_package_gpgcheck = xml_repo.get_package_gpgcheck()
log.info('Setting up repository %s', repo_source)
log.info('--> Type: %s', repo_type)
if repo_priority:
log.info('--> Priority: %s', repo_priority)
uri = Uri(repo_source, repo_type)
repo_source_translated = uri.translate()
log.info('--> Translated: %s', repo_source_translated)
if not repo_alias:
repo_alias = uri.alias()
log.info('--> Alias: %s', repo_alias)
if not uri.is_remote() and not os.path.exists(
repo_source_translated
):
log.warning(
'repository %s does not exist and will be skipped',
repo_source
)
continue
if not uri.is_remote():
self.root_bind.mount_shared_directory(repo_source_translated)
repo.add_repo(
repo_alias, repo_source_translated,
repo_type, repo_priority, repo_dist, repo_components,
repo_user, repo_secret, uri.credentials_file_name(),
repo_repository_gpgcheck, repo_package_gpgcheck
)
if clear_cache:
repo.delete_repo_cache(repo_alias)
self.uri_list.append(uri)
repo.cleanup_unused_repos()
return PackageManager(
repo, package_manager
)
def get_disksize_mbytes(self):
"""
Precalculate disk size requirements in mbytes
:return: disk size mbytes
:rtype: int
"""
log.info('Precalculating required disk size')
calculated_disk_mbytes = 0
root_filesystem_mbytes = self.rootsize.customize(
self.rootsize.accumulate_mbyte_file_sizes(), self.filesystem)
calculated_disk_mbytes += root_filesystem_mbytes
log.info('--> system data with filesystem overhead needs %s MB',
root_filesystem_mbytes)
if self.volume_manager and self.volume_manager == 'lvm':
lvm_overhead_mbytes = Defaults.get_lvm_overhead_mbytes()
log.info('--> LVM overhead adding %s MB', lvm_overhead_mbytes)
calculated_disk_mbytes += lvm_overhead_mbytes
volume_mbytes = self._accumulate_volume_size(
root_filesystem_mbytes)
if volume_mbytes:
calculated_disk_mbytes += volume_mbytes
log.info('--> volume(s) size setup adding %s MB',
volume_mbytes)
legacy_bios_mbytes = self.firmware.get_legacy_bios_partition_size()
if legacy_bios_mbytes:
calculated_disk_mbytes += legacy_bios_mbytes
log.info('--> legacy bios boot partition adding %s MB',
legacy_bios_mbytes)
boot_mbytes = self.boot_partition_size()
if boot_mbytes:
calculated_disk_mbytes += boot_mbytes
log.info('--> boot partition adding %s MB', boot_mbytes)
if self.spare_part_mbytes:
calculated_disk_mbytes += self.spare_part_mbytes
log.info('--> spare partition adding %s MB',
self.spare_part_mbytes)
efi_mbytes = self.firmware.get_efi_partition_size()
if efi_mbytes:
calculated_disk_mbytes += efi_mbytes
log.info('--> EFI partition adding %s MB', efi_mbytes)
prep_mbytes = self.firmware.get_prep_partition_size()
if prep_mbytes:
calculated_disk_mbytes += prep_mbytes
log.info('--> PReP partition adding %s MB', prep_mbytes)
recovery_mbytes = self._inplace_recovery_partition_size()
if recovery_mbytes:
calculated_disk_mbytes += recovery_mbytes
log.info('--> In-place recovery partition adding: %s MB',
recovery_mbytes)
if not self.configured_size:
log.info('Using calculated disk size: %d MB',
calculated_disk_mbytes)
return calculated_disk_mbytes
elif self.configured_size.additive:
result_disk_mbytes = \
self.configured_size.mbytes + calculated_disk_mbytes
log.info(
'Using configured disk size: %d MB + %d MB calculated = %d MB',
self.configured_size.mbytes, calculated_disk_mbytes,
result_disk_mbytes)
return result_disk_mbytes
else:
log.info('Using configured disk size: %d MB',
self.configured_size.mbytes)
if self.configured_size.mbytes < calculated_disk_mbytes:
log.warning(
'--> Configured size smaller than calculated size: %d MB',
calculated_disk_mbytes)
return self.configured_size.mbytes
def _setup_default_grub(self):
"""
Create or update etc/default/grub by parameters required
according to the root filesystem setup
* GRUB_TIMEOUT
* SUSE_BTRFS_SNAPSHOT_BOOTING
* GRUB_BACKGROUND
* GRUB_THEME
* GRUB_USE_LINUXEFI
* GRUB_USE_INITRDEFI
* GRUB_SERIAL_COMMAND
* GRUB_CMDLINE_LINUX_DEFAULT
"""
grub_default_entries = {
'GRUB_TIMEOUT': self.timeout
}
if self.cmdline:
grub_default_entries['GRUB_CMDLINE_LINUX_DEFAULT'] = '"{0}"'.format(
self.cmdline
)
if self.terminal and self.terminal == 'serial':
serial_format = '"serial {0} {1} {2} {3} {4}"'
grub_default_entries['GRUB_SERIAL_COMMAND'] = serial_format.format(
'--speed=38400',
'--unit=0',
'--word=8',
'--parity=no',
'--stop=1'
)
if self.theme:
theme_setup = '{0}/{1}/theme.txt'
grub_default_entries['GRUB_THEME'] = theme_setup.format(
''.join(['/boot/', self.boot_directory_name, '/themes']),
self.theme
)
theme_background = '{0}/{1}/background.png'.format(
''.join(['/boot/', self.boot_directory_name, '/themes']),
self.theme
)
if os.path.exists(os.sep.join([self.root_dir, theme_background])):
grub_default_entries['GRUB_BACKGROUND'] = theme_background
if self.firmware.efi_mode():
# linuxefi/initrdefi only exist on x86, others always use efi
if self.arch == 'ix86' or self.arch == 'x86_64':
grub_default_entries['GRUB_USE_LINUXEFI'] = 'true'
grub_default_entries['GRUB_USE_INITRDEFI'] = 'true'
if self.xml_state.build_type.get_btrfs_root_is_snapshot():
grub_default_entries['SUSE_BTRFS_SNAPSHOT_BOOTING'] = 'true'
if grub_default_entries:
log.info('Writing grub2 defaults file')
grub_default_location = ''.join([self.root_dir, '/etc/default/'])
if os.path.exists(grub_default_location):
grub_default_file = ''.join([grub_default_location, 'grub'])
grub_default = SysConfig(grub_default_file)
grub_default_entries_sorted = OrderedDict(
sorted(grub_default_entries.items())
)
for key, value in list(grub_default_entries_sorted.items()):
log.info('--> {0}:{1}'.format(key, value))
grub_default[key] = value
grub_default.write()
def __del__(self):
if self.filesystem_mount:
log.info('Cleaning up %s instance', type(self).__name__)
self.filesystem_mount.umount()
def __del__(self):
if self.call_destructor:
log.info('Cleaning up %s instance', type(self).__name__)
for directory in self.temp_directories:
if directory and os.path.exists(directory):
Path.wipe(directory)
def __del__(self):
log.info('Cleaning up %s instance', type(self).__name__)
self.boot_mount.umount()
def _setup_default_grub(self): # noqa: C901
"""
Create or update etc/default/grub by parameters required
according to the root filesystem setup
* GRUB_TIMEOUT
* SUSE_BTRFS_SNAPSHOT_BOOTING
* GRUB_BACKGROUND
* GRUB_THEME
* GRUB_USE_LINUXEFI
* GRUB_USE_INITRDEFI
* GRUB_SERIAL_COMMAND
* GRUB_CMDLINE_LINUX_DEFAULT
* GRUB_GFXMODE
* GRUB_TERMINAL
* GRUB_DISTRIBUTOR
"""
grub_default_entries = {
'GRUB_TIMEOUT': self.timeout,
'GRUB_GFXMODE': self.gfxmode,
'GRUB_TERMINAL': '"{0}"'.format(self.terminal),
'GRUB_DISTRIBUTOR': '"{0}"'.format(self.get_menu_entry_title())
}
if self.cmdline:
grub_default_entries[
'GRUB_CMDLINE_LINUX_DEFAULT'] = '"{0}"'.format(self.cmdline)
if self.terminal and 'serial' in self.terminal:
serial_format = '"serial {0} {1} {2} {3} {4}"'
grub_default_entries['GRUB_SERIAL_COMMAND'] = serial_format.format(
'--speed=38400', '--unit=0', '--word=8', '--parity=no',
'--stop=1')
if self.theme:
theme_setup = '{0}/{1}/theme.txt'
grub_default_entries['GRUB_THEME'] = theme_setup.format(
''.join(['/boot/', self.boot_directory_name, '/themes']),
self.theme)
theme_background = '{0}/{1}/background.png'.format(
''.join(['/boot/', self.boot_directory_name, '/themes']),
self.theme)
if os.path.exists(os.sep.join([self.root_dir, theme_background])):
grub_default_entries['GRUB_BACKGROUND'] = theme_background
if self.firmware.efi_mode():
# linuxefi/initrdefi only exist on x86, others always use efi
if self.arch == 'ix86' or self.arch == 'x86_64':
use_linuxefi_implemented = Command.run([
'grep', '-q', 'GRUB_USE_LINUXEFI',
Defaults.get_grub_config_tool()
],
raise_on_error=False)
if use_linuxefi_implemented.returncode == 0:
grub_default_entries['GRUB_USE_LINUXEFI'] = 'true'
grub_default_entries['GRUB_USE_INITRDEFI'] = 'true'
if self.xml_state.build_type.get_btrfs_root_is_snapshot():
grub_default_entries['SUSE_BTRFS_SNAPSHOT_BOOTING'] = 'true'
if self.custom_args.get('boot_is_crypto'):
grub_default_entries['GRUB_ENABLE_CRYPTODISK'] = 'y'
if grub_default_entries:
log.info('Writing grub2 defaults file')
grub_default_location = ''.join([self.root_dir, '/etc/default/'])
if os.path.exists(grub_default_location):
grub_default_file = ''.join([grub_default_location, 'grub'])
grub_default = SysConfig(grub_default_file)
grub_default_entries_sorted = OrderedDict(
sorted(grub_default_entries.items()))
for key, value in list(grub_default_entries_sorted.items()):
log.info('--> {0}:{1}'.format(key, value))
grub_default[key] = value
grub_default.write()
def create_install_iso(self):
"""
Create an install ISO from the disk_image as hybrid ISO
bootable via legacy BIOS, EFI and as disk from Stick
Image types which triggers this builder are:
* installiso="true|false"
* installstick="true|false"
"""
self.media_dir = mkdtemp(prefix='kiwi_install_media.',
dir=self.target_dir)
# unpack cdroot user files to media dir
self.setup.import_cdroot_files(self.media_dir)
# custom iso metadata
self.custom_iso_args = {
'meta_data': {
'volume_id': self.iso_volume_id,
'mbr_id': self.mbrid.get_id(),
'efi_mode': self.firmware.efi_mode()
}
}
# the system image transfer is checked against a checksum
log.info('Creating disk image checksum')
self.squashed_contents = mkdtemp(prefix='kiwi_install_squashfs.',
dir=self.target_dir)
checksum = Checksum(self.diskname)
checksum.md5(self.squashed_contents + '/' + self.md5name)
# the system image name is stored in a config file
self._write_install_image_info_to_iso_image()
if self.initrd_system == 'kiwi':
self._write_install_image_info_to_boot_image()
# the system image is stored as squashfs embedded file
log.info('Creating squashfs embedded disk image')
Command.run([
'cp', '-l', self.diskname,
self.squashed_contents + '/' + self.squashed_diskname
])
squashed_image_file = ''.join(
[self.target_dir, '/', self.squashed_diskname, '.squashfs'])
squashed_image = FileSystemSquashFs(
device_provider=None,
root_dir=self.squashed_contents,
custom_args={
'create_options': self.xml_state.get_fs_create_option_list()
})
squashed_image.create_on_file(squashed_image_file)
Command.run(['mv', squashed_image_file, self.media_dir])
log.info('Setting up install image bootloader configuration')
if self.firmware.efi_mode():
# setup bootloader config to boot the ISO via EFI
# This also embedds an MBR and the respective BIOS modules
# for compat boot. The complete bootloader setup will be
# based on grub
bootloader_config = BootLoaderConfig(
'grub2',
self.xml_state,
root_dir=self.root_dir,
boot_dir=self.media_dir,
custom_args={
'grub_directory_name':
Defaults.get_grub_boot_directory_name(self.root_dir)
})
bootloader_config.setup_install_boot_images(
mbrid=self.mbrid, lookup_path=self.root_dir)
else:
# setup bootloader config to boot the ISO via isolinux.
# This allows for booting on x86 platforms in BIOS mode
# only.
bootloader_config = BootLoaderConfig('isolinux',
self.xml_state,
root_dir=self.root_dir,
boot_dir=self.media_dir)
IsoToolsBase.setup_media_loader_directory(
self.boot_image_task.boot_root_directory, self.media_dir,
bootloader_config.get_boot_theme())
bootloader_config.setup_install_image_config(mbrid=self.mbrid)
bootloader_config.write()
# create initrd for install image
log.info('Creating install image boot image')
self._create_iso_install_kernel_and_initrd()
# the system image initrd is stored to allow kexec
self._copy_system_image_initrd_to_iso_image()
# create iso filesystem from media_dir
log.info('Creating ISO filesystem')
iso_image = FileSystemIsoFs(device_provider=None,
root_dir=self.media_dir,
custom_args=self.custom_iso_args)
iso_image.create_on_file(self.isoname)
def create(self):
"""
Build a pxe image set consisting out of a boot image(initrd)
plus its appropriate kernel files and the root filesystem
image with a checksum. The result can be used within the kiwi
PXE boot infrastructure
Image types which triggers this builder are:
* image="pxe"
:raises KiwiPxeBootImageError: if no kernel or hipervisor is found
in boot image tree
:return: result
:rtype: instance of :class:`Result`
"""
log.info('Creating PXE root filesystem image')
self.filesystem.create()
os.rename(self.filesystem.filename, self.image_name)
self.image = self.image_name
if self.compressed:
log.info('xz compressing root filesystem image')
compress = Compress(self.image)
compress.xz(self.xz_options)
self.image = compress.compressed_filename
log.info('Creating PXE root filesystem MD5 checksum')
checksum = Checksum(self.image)
checksum.md5(self.checksum_name)
# prepare boot(initrd) root system
log.info('Creating PXE boot image')
self.boot_image_task.prepare()
# export modprobe configuration to boot image
self.system_setup.export_modprobe_setup(
self.boot_image_task.boot_root_directory)
# extract kernel from boot(initrd) root system
kernel = Kernel(self.boot_image_task.boot_root_directory)
kernel_data = kernel.get_kernel()
if kernel_data:
self.kernel_filename = ''.join([
os.path.basename(self.image_name), '-', kernel_data.version,
'.kernel'
])
kernel.copy_kernel(self.target_dir, self.kernel_filename)
else:
raise KiwiPxeBootImageError(
'No kernel in boot image tree %s found' %
self.boot_image_task.boot_root_directory)
# extract hypervisor from boot(initrd) root system
if self.xen_server:
kernel_data = kernel.get_xen_hypervisor()
if kernel_data:
self.hypervisor_filename = ''.join(
[os.path.basename(self.image_name), '-', kernel_data.name])
kernel.copy_xen_hypervisor(self.target_dir,
self.hypervisor_filename)
self.result.add(key='xen_hypervisor',
filename=self.target_dir + '/' +
self.hypervisor_filename,
use_for_bundle=True,
compress=False,
shasum=True)
else:
raise KiwiPxeBootImageError(
'No hypervisor in boot image tree %s found' %
self.boot_image_task.boot_root_directory)
# create initrd for pxe boot
self.boot_image_task.create_initrd()
# put results into a tarball
if not self.xz_options:
self.xz_options = Defaults.get_xz_compression_options()
pxe_tarball_files = [
self.kernel_filename,
os.path.basename(self.boot_image_task.initrd_filename),
os.path.basename(self.image),
os.path.basename(self.checksum_name)
]
pxe_tarball = ArchiveTar(self.archive_name,
create_from_file_list=True,
file_list=pxe_tarball_files)
if self.compressed:
self.archive_name = pxe_tarball.create(self.target_dir)
else:
self.archive_name = pxe_tarball.create_xz_compressed(
self.target_dir, xz_options=self.xz_options)
self.result.verify_image_size(
self.runtime_config.get_max_size_constraint(), self.archive_name)
# store results
self.result.add(
key='pxe_archive',
filename=self.archive_name,
use_for_bundle=True,
compress=self.runtime_config.get_bundle_compression(default=False),
shasum=True)
# create image root metadata
self.result.add(key='image_packages',
filename=self.system_setup.export_package_list(
self.target_dir),
use_for_bundle=True,
compress=False,
shasum=False)
self.result.add(key='image_verified',
filename=self.system_setup.export_package_verification(
self.target_dir),
use_for_bundle=True,
compress=False,
shasum=False)
return self.result
def __init__(self, root_dir, custom_args=None): # noqa: C901
self.root_dir = root_dir
self.oci_dir = None
self.oci_root_dir = None
self.xz_options = None
self.container_name = 'kiwi-container'
self.container_tag = 'latest'
self.entry_command = []
self.entry_subcommand = []
self.maintainer = []
self.user = []
self.workingdir = []
self.expose_ports = []
self.volumes = []
self.environment = []
self.labels = []
if custom_args:
if 'container_name' in custom_args:
self.container_name = custom_args['container_name']
if 'container_tag' in custom_args:
self.container_tag = custom_args['container_tag']
if 'entry_command' in custom_args:
self.entry_command = custom_args['entry_command']
if 'entry_subcommand' in custom_args:
self.entry_subcommand = custom_args['entry_subcommand']
if 'maintainer' in custom_args:
self.maintainer = custom_args['maintainer']
if 'user' in custom_args:
self.user = custom_args['user']
if 'workingdir' in custom_args:
self.workingdir = custom_args['workingdir']
if 'expose_ports' in custom_args:
self.expose_ports = custom_args['expose_ports']
if 'volumes' in custom_args:
self.volumes = custom_args['volumes']
if 'environment' in custom_args:
self.environment = custom_args['environment']
if 'labels' in custom_args:
self.labels = custom_args['labels']
if 'xz_options' in custom_args:
self.xz_options = custom_args['xz_options']
# for builds inside the buildservice we include a reference to the
# specific build. Thus disturl label only exists inside the
# buildservice.
if Defaults.is_buildservice_worker():
self._append_buildservice_disturl_label()
if not custom_args or 'container_name' not in custom_args:
log.info('No container configuration provided, '
'using default container name "kiwi-container:latest"')
if not self.entry_command and not self.entry_subcommand:
self.entry_subcommand = ['--config.cmd=/bin/bash']
