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
"""
self.media_dir = mkdtemp(prefix="install-media.", dir=self.target_dir)
# custom iso metadata
self.custom_iso_args = ["-V", '"KIWI Installation System"', "-A", self.mbrid.get_id()]
# the system image transfer is checked against a checksum
log.info("Creating disk image checksum")
self.squashed_contents = mkdtemp(prefix="install-squashfs.", dir=self.target_dir)
checksum = Checksum(self.diskname)
checksum.md5(self.squashed_contents + "/" + self.md5name)
# the kiwi initrd code triggers the install by trigger files
self.__create_iso_install_trigger_files()
# 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)
squashed_image.create_on_file(squashed_image_file)
Command.run(["mv", squashed_image_file, self.media_dir])
# setup bootloader config to boot the ISO via isolinux
log.info("Setting up install image bootloader configuration")
bootloader_config_isolinux = BootLoaderConfig("isolinux", self.xml_state, self.media_dir)
bootloader_config_isolinux.setup_install_boot_images(
mbrid=None, lookup_path=self.boot_image_task.boot_root_directory
)
bootloader_config_isolinux.setup_install_image_config(mbrid=None)
bootloader_config_isolinux.write()
# setup bootloader config to boot the ISO via EFI
bootloader_config_grub = BootLoaderConfig("grub2", self.xml_state, self.media_dir)
bootloader_config_grub.setup_install_boot_images(
mbrid=self.mbrid, lookup_path=self.boot_image_task.boot_root_directory
)
bootloader_config_grub.setup_install_image_config(mbrid=self.mbrid)
bootloader_config_grub.write()
# create initrd for install image
log.info("Creating install image boot image")
self.__create_iso_install_kernel_and_initrd()
# 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_header_offset = iso_image.create_on_file(self.isoname)
# make it hybrid
Iso.create_hybrid(iso_header_offset, self.mbrid, self.isoname)
def create(self):
# media dir to store CD contents
self.media_dir = mkdtemp(prefix='live-media.', dir=self.target_dir)
rootsize = SystemSize(self.media_dir)
# custom iso metadata
log.info('Using following live ISO metadata:')
log.info('--> Application id: %s', self.mbrid.get_id())
log.info('--> Publisher: %s', Defaults.get_publisher())
custom_iso_args = [
'-A',
self.mbrid.get_id(),
'-p',
'"' + Defaults.get_preparer() + '"',
'-publisher',
'"' + Defaults.get_publisher() + '"',
]
if self.volume_id:
log.info('--> Volume id: %s', self.volume_id)
custom_iso_args.append('-V')
custom_iso_args.append('"' + self.volume_id + '"')
# prepare boot(initrd) root system
log.info('Preparing live ISO boot system')
self.boot_image_task.prepare()
# export modprobe configuration to boot image
self.system_setup.export_modprobe_setup(
self.boot_image_task.boot_root_directory)
# pack system into live boot structure
log.info('Packing system into live ISO type: %s', self.live_type)
if self.live_type in self.types:
live_type_image = FileSystem(name=self.types[self.live_type],
device_provider=None,
root_dir=self.root_dir)
live_type_image.create_on_file(self.live_image_file)
Command.run(['mv', self.live_image_file, self.media_dir])
self.__create_live_iso_client_config(self.live_type)
else:
raise KiwiLiveBootImageError('live ISO type "%s" not supported' %
self.live_type)
# setup bootloader config to boot the ISO via isolinux
log.info('Setting up isolinux bootloader configuration')
bootloader_config_isolinux = BootLoaderConfig('isolinux',
self.xml_state,
self.media_dir)
bootloader_config_isolinux.setup_live_boot_images(
mbrid=None, lookup_path=self.boot_image_task.boot_root_directory)
bootloader_config_isolinux.setup_live_image_config(mbrid=None)
bootloader_config_isolinux.write()
# setup bootloader config to boot the ISO via EFI
if self.firmware.efi_mode():
log.info('Setting up EFI grub bootloader configuration')
bootloader_config_grub = BootLoaderConfig('grub2', self.xml_state,
self.media_dir)
bootloader_config_grub.setup_live_boot_images(
mbrid=self.mbrid,
lookup_path=self.boot_image_task.boot_root_directory)
bootloader_config_grub.setup_live_image_config(mbrid=self.mbrid)
bootloader_config_grub.write()
# create initrd for live image
log.info('Creating live ISO boot image')
self.__create_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.append('-allow-limited-size')
custom_iso_args.append('-udf')
# 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_header_offset = iso_image.create_on_file(self.isoname)
# make it hybrid
if self.hybrid:
Iso.create_hybrid(iso_header_offset, self.mbrid, self.isoname)
self.result.add('live_image', self.isoname)
return self.result
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
"""
self.media_dir = mkdtemp(
prefix='install-media.', dir=self.target_dir
)
# custom iso metadata
self.custom_iso_args = [
'-V', '"KIWI Installation System"',
'-A', self.mbrid.get_id()
]
# the system image transfer is checked against a checksum
log.info('Creating disk image checksum')
self.squashed_contents = mkdtemp(
prefix='install-squashfs.', dir=self.target_dir
)
checksum = Checksum(self.diskname)
checksum.md5(self.squashed_contents + '/' + self.md5name)
# the kiwi initrd code triggers the install by trigger files
self.__create_iso_install_trigger_files()
# 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
)
squashed_image.create_on_file(squashed_image_file)
Command.run(
['mv', squashed_image_file, self.media_dir]
)
# setup bootloader config to boot the ISO via isolinux
log.info('Setting up install image bootloader configuration')
bootloader_config_isolinux = BootLoaderConfig(
'isolinux', self.xml_state, self.media_dir
)
bootloader_config_isolinux.setup_install_boot_images(
mbrid=None,
lookup_path=self.boot_image_task.boot_root_directory
)
bootloader_config_isolinux.setup_install_image_config(
mbrid=None
)
bootloader_config_isolinux.write()
# setup bootloader config to boot the ISO via EFI
bootloader_config_grub = BootLoaderConfig(
'grub2', self.xml_state, self.media_dir
)
bootloader_config_grub.setup_install_boot_images(
mbrid=self.mbrid,
lookup_path=self.boot_image_task.boot_root_directory
)
bootloader_config_grub.setup_install_image_config(
mbrid=self.mbrid
)
bootloader_config_grub.write()
# create initrd for install image
log.info('Creating install image boot image')
self.__create_iso_install_kernel_and_initrd()
# 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_header_offset = iso_image.create_on_file(self.isoname)
# make it hybrid
Iso.create_hybrid(
iso_header_offset, self.mbrid, self.isoname
)
def create_on_file(self, filename, label=None):
# there is no label which could be set for an iso filesystem
# thus this parameter is not used
iso = Iso(self.root_dir)
iso.init_iso_creation_parameters(self.custom_args)
iso.add_efi_loader_parameters()
Command.run(['genisoimage'] + iso.get_iso_creation_parameters() +
['-o', filename, self.root_dir])
hybrid_offset = iso.create_header_end_block(filename)
Command.run([
'genisoimage', '-hide', iso.header_end_name, '-hide-joliet',
iso.header_end_name
] + iso.get_iso_creation_parameters() +
['-o', filename, self.root_dir])
iso.relocate_boot_catalog(filename)
iso.fix_boot_catalog(filename)
return hybrid_offset
def create(self):
# media dir to store CD contents
self.media_dir = mkdtemp(
prefix='live-media.', dir=self.target_dir
)
rootsize = SystemSize(self.media_dir)
# custom iso metadata
log.info('Using following live ISO metadata:')
log.info('--> Application id: %s', self.mbrid.get_id())
log.info('--> Publisher: %s', Defaults.get_publisher())
custom_iso_args = [
'-A', self.mbrid.get_id(),
'-p', '"' + Defaults.get_preparer() + '"',
'-publisher', '"' + Defaults.get_publisher() + '"',
]
if self.volume_id:
log.info('--> Volume id: %s', self.volume_id)
custom_iso_args.append('-V')
custom_iso_args.append('"' + self.volume_id + '"')
# prepare boot(initrd) root system
log.info('Preparing live ISO boot system')
self.boot_image_task.prepare()
# export modprobe configuration to boot image
self.system_setup.export_modprobe_setup(
self.boot_image_task.boot_root_directory
)
# pack system into live boot structure
log.info('Packing system into live ISO type: %s', self.live_type)
if self.live_type in self.types:
live_type_image = FileSystem(
name=self.types[self.live_type],
device_provider=None,
root_dir=self.root_dir
)
live_type_image.create_on_file(self.live_image_file)
Command.run(
['mv', self.live_image_file, self.media_dir]
)
self.__create_live_iso_client_config(self.live_type)
else:
raise KiwiLiveBootImageError(
'live ISO type "%s" not supported' % self.live_type
)
# setup bootloader config to boot the ISO via isolinux
log.info('Setting up isolinux bootloader configuration')
bootloader_config_isolinux = BootLoaderConfig(
'isolinux', self.xml_state, self.media_dir
)
bootloader_config_isolinux.setup_live_boot_images(
mbrid=None,
lookup_path=self.boot_image_task.boot_root_directory
)
bootloader_config_isolinux.setup_live_image_config(
mbrid=None
)
bootloader_config_isolinux.write()
# setup bootloader config to boot the ISO via EFI
if self.firmware.efi_mode():
log.info('Setting up EFI grub bootloader configuration')
bootloader_config_grub = BootLoaderConfig(
'grub2', self.xml_state, self.media_dir
)
bootloader_config_grub.setup_live_boot_images(
mbrid=self.mbrid,
lookup_path=self.boot_image_task.boot_root_directory
)
bootloader_config_grub.setup_live_image_config(
mbrid=self.mbrid
)
bootloader_config_grub.write()
# create initrd for live image
log.info('Creating live ISO boot image')
self.__create_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.append('-allow-limited-size')
custom_iso_args.append('-udf')
# 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_header_offset = iso_image.create_on_file(self.isoname)
# make it hybrid
if self.hybrid:
Iso.create_hybrid(
iso_header_offset, self.mbrid, self.isoname
)
self.result.add(
'live_image', self.isoname
)
return self.result
def create_on_file(self, filename, label=None):
# there is no label which could be set for an iso filesystem
# thus this parameter is not used
iso = Iso(self.root_dir)
iso.init_iso_creation_parameters(self.custom_args)
iso.add_efi_loader_parameters()
Command.run(
[
'genisoimage'
] + iso.get_iso_creation_parameters() + [
'-o', filename, self.root_dir
]
)
hybrid_offset = iso.create_header_end_block(filename)
Command.run(
[
'genisoimage',
'-hide', iso.header_end_name,
'-hide-joliet', iso.header_end_name
] + iso.get_iso_creation_parameters() + [
'-o', filename, self.root_dir
]
)
iso.relocate_boot_catalog(filename)
iso.fix_boot_catalog(filename)
return hybrid_offset
