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': '/boot/' + self.arch + '/loader', 'boot_directory_name': self.boot_directory_name } 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 setup_install_image_config(self, mbrid, hypervisor='xen.gz', kernel='linux', initrd='initrd'): """ Create grub2 config file to boot from an ISO install 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 install config file from template') self.iso_boot = True parameters = { 'search_params': '--file --set=root /boot/' + mbrid.get_id(), 'default_boot': self.get_install_image_boot_default(), 'kernel_file': kernel, 'initrd_file': initrd, 'boot_options': ' '.join([self.cmdline] + self.install_boot_options), 'failsafe_boot_options': ' '.join([self.cmdline_failsafe] + self.install_boot_options), 'gfxmode': self.gfxmode, 'theme': self.theme, 'boot_timeout': self.timeout, 'title': self.get_menu_entry_install_title(), 'bootpath': self.get_boot_path('iso'), 'boot_directory_name': self.boot_directory_name, 'efi_image_name': Defaults.get_efi_image_name(self.arch), 'terminal_setup': self.terminal } if self.multiboot: log.info('--> Using multiboot install template') parameters['hypervisor'] = hypervisor template = self.grub2.get_multiboot_install_template( self.failsafe_boot, self.terminal, self.continue_on_timeout) else: log.info('--> Using standard boot install template') hybrid_boot = True template = self.grub2.get_install_template( self.failsafe_boot, hybrid_boot, self.terminal, self.continue_on_timeout) try: self.config = template.substitute(parameters) except Exception as e: raise KiwiTemplateError('%s: %s' % (type(e).__name__, format(e)))
def setup_live_image_config(self, mbrid, hypervisor='xen.gz', kernel='linux', initrd='initrd'): """ Create isolinux.cfg in memory from a template suitable to boot a live system from an ISO image in BIOS boot mode :param string mbrid: mbrid file name on boot device :param string hypervisor: hypervisor name :param string kernel: kernel name :param string initrd: initrd name """ # mbrid parameter is not used, the information is placed as the # application id when creating the iso filesystem. Thus not part # of the configuration file log.info('Creating isolinux live ISO config file from template') parameters = { 'default_boot': self.get_menu_entry_title(plain=True), '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, 'boot_timeout': self.timeout, 'title': self.get_menu_entry_title(plain=True) } if self.multiboot: log.info('--> Using multiboot standard ISO template') parameters['hypervisor'] = hypervisor template = self.isolinux.get_multiboot_template( self.failsafe_boot, self._have_theme(), self.terminal, self.mediacheck_boot) else: log.info('--> Using standard ISO template') template = self.isolinux.get_template(self.failsafe_boot, self._have_theme(), self.terminal, self.mediacheck_boot) try: self.config = template.substitute(parameters) template = self.isolinux.get_message_template() self.config_message = template.substitute(parameters) except Exception as e: raise KiwiTemplateError('%s: %s' % (type(e).__name__, format(e)))
def setup_disk_image_config( self, boot_uuid, root_uuid, hypervisor='xen.gz', kernel=None, initrd=None, boot_options='' ): """ Create the grub.cfg in memory from a template suitable to boot from a disk image :param string boot_uuid: boot device UUID :param string root_uuid: root device UUID :param string hypervisor: hypervisor name :param string kernel: kernel name :param string initrd: initrd name :param string boot_options: kernel options as string """ log.info('Creating grub2 config file from template') self.cmdline = ' '.join( [self.get_boot_cmdline(root_uuid), boot_options] ) self.cmdline_failsafe = ' '.join( [self.cmdline, Defaults.get_failsafe_kernel_options(), boot_options] ) parameters = { 'search_params': ' '.join(['--fs-uuid', '--set=root', boot_uuid]), 'default_boot': '0', 'kernel_file': kernel, 'initrd_file': initrd, 'boot_options': self.cmdline, 'failsafe_boot_options': self.cmdline_failsafe, 'gfxmode': self.gfxmode, 'theme': self.theme, 'boot_timeout': self.timeout, 'title': self.get_menu_entry_title(), 'bootpath': self.get_boot_path('disk'), 'boot_directory_name': self.boot_directory_name, 'terminal_setup': self.terminal } if self.multiboot: log.info('--> Using multiboot disk template') parameters['hypervisor'] = hypervisor template = self.grub2.get_multiboot_disk_template( self.failsafe_boot, self.terminal ) else: log.info('--> Using hybrid boot disk template') template = self.grub2.get_disk_template( self.failsafe_boot, self.hybrid_boot, self.terminal ) try: self.config = template.substitute(parameters) except Exception as e: raise KiwiTemplateError( '%s: %s' % (type(e).__name__, format(e)) )
def setup_disk_image_config(self, boot_uuid=None, root_uuid=None, hypervisor=None, kernel=None, initrd=None, boot_options=''): """ Create the zipl config in memory from a template suitable to boot from a disk image. :param string boot_uuid: unused :param string root_uuid: unused :param string hypervisor: unused :param string kernel: kernel name :param string initrd: initrd name :param string boot_options: kernel options as string """ log.info('Creating zipl config file from template') parameters = { 'device': self.target_device, 'target_type': self.target_type, 'blocksize': self.target_blocksize, 'offset': self._get_target_offset(), 'geometry': self._get_target_geometry(), 'default_boot': '1', 'bootpath': self.bootpath, 'boot_timeout': self.timeout, 'title': self.quote_title(self.get_menu_entry_title()), 'kernel_file': kernel, 'initrd_file': initrd, 'boot_options': ' '.join([self.cmdline, boot_options]), 'failsafe_boot_options': ' '.join([self.cmdline_failsafe, boot_options]) } log.info('--> Using standard disk boot template') template = self.zipl.get_template(self.failsafe_boot) try: self.config = template.substitute(parameters) except Exception as e: raise KiwiTemplateError('%s: %s' % (type(e).__name__, format(e)))
def _create_vmware_settings_file(self): """ In order to run a vmdk image in VMware products a settings file is needed or the possibility to convert machine settings into an ovf via VMware's proprietary ovftool """ displayname = self.xml_state.xml_data.get_displayname() template_record = { 'display_name': displayname or self.xml_state.xml_data.get_name(), 'vmdk_file': os.path.basename(self.get_target_file_path_for_format('vmdk')), 'virtual_hardware_version': '9', 'guest_os': 'suse-64', 'disk_id': '0' } # Basic setup machine_setup = self.xml_state.get_build_type_machine_section() memory_setup = None cpu_setup = None if machine_setup: memory_setup = machine_setup.get_memory() hardware_version = machine_setup.get_HWversion() guest_os = machine_setup.get_guestOS() cpu_setup = machine_setup.get_ncpus() if hardware_version: template_record['virtual_hardware_version'] = hardware_version if guest_os: template_record['guest_os'] = guest_os if memory_setup: template_record['memory_size'] = memory_setup if cpu_setup: template_record['number_of_cpus'] = cpu_setup # CD/DVD setup iso_setup = self.xml_state.get_build_type_vmdvd_section() iso_controller = 'ide' if iso_setup: iso_controller = iso_setup.get_controller() or iso_controller template_record['iso_id'] = iso_setup.get_id() # Network setup network_entries = self.xml_state.get_build_type_vmnic_entries() network_setup = {} for network_entry in network_entries: network_setup[network_entry.get_interface() or '0'] = { 'driver': network_entry.get_driver(), 'connection_type': network_entry.get_mode(), 'mac': network_entry.get_mac() or 'generated', } # Disk setup disk_setup = self.xml_state.get_build_type_vmdisk_section() disk_controller = 'ide' if disk_setup: disk_controller = disk_setup.get_controller() or disk_controller disk_id = disk_setup.get_id() if not disk_controller == 'ide': template_record['scsi_controller_name'] = disk_controller if disk_id: template_record['disk_id'] = disk_id # Addition custom entries custom_entries = self.xml_state.get_build_type_vmconfig_entries() # Build settings template and write settings file settings_template = VmwareSettingsTemplate().get_template( memory_setup, cpu_setup, network_setup, iso_setup, disk_controller, iso_controller) try: settings_file = self.get_target_file_path_for_format('vmx') with open(settings_file, 'w') as config: config.write(settings_template.substitute(template_record)) for custom_entry in custom_entries: config.write(custom_entry + os.linesep) except Exception as e: raise KiwiTemplateError('%s: %s' % (type(e).__name__, format(e)))