def post_install(self): """ Perform post-installation tasks. """ progressQ.send_message(_("Performing post-installation setup tasks")) payload_utils.unmount(INSTALL_TREE, raise_exc=True) super().post_install() # Not using BLS configuration, skip it if os.path.exists(conf.target.system_root + "/usr/sbin/new-kernel-pkg"): return # Remove any existing BLS entries, they will not match the new system's # machine-id or /boot mountpoint. for file in glob.glob(conf.target.system_root + "/boot/loader/entries/*.conf"): log.info("Removing old BLS entry: %s", file) os.unlink(file) # Create new BLS entries for this system for kernel in self.kernel_version_list: log.info("Regenerating BLS info for %s", kernel) util.execInSysroot( "kernel-install", ["add", kernel, "/lib/modules/{0}/vmlinuz".format(kernel)])
def postInstall(self): """ Perform post-installation tasks. """ progressQ.send_message(_("Performing post-installation setup tasks")) blivet.util.umount(INSTALL_TREE) super().postInstall() # Make sure the new system has a machine-id, it won't boot without it if not os.path.exists(util.getSysroot() + "/etc/machine-id"): util.execInSysroot("systemd-machine-id-setup", [])
def _run(self, cmd, args, required=True): if not os.path.lexists(util.getSysroot() + cmd): if required: msg = _("%s is missing. Cannot setup authentication.") % cmd raise KickstartError(msg) else: return try: util.execInSysroot(cmd, args) except RuntimeError as msg: authselect_log.error("Error running %s %s: %s", cmd, args, msg)
def install(self): """ Install the payload. """ if self.source_size <= 0: raise PayloadInstallError("Nothing to install") self.pct_lock = Lock() self.pct = 0 threadMgr.add( AnacondaThread(name=THREAD_LIVE_PROGRESS, target=self.progress)) cmd = "rsync" # preserve: permissions, owners, groups, ACL's, xattrs, times, # symlinks, hardlinks # go recursively, include devices and special files, don't cross # file system boundaries args = [ "-pogAXtlHrDx", "--exclude", "/dev/", "--exclude", "/proc/", "--exclude", "/sys/", "--exclude", "/run/", "--exclude", "/boot/*rescue*", "--exclude", "/etc/machine-id", INSTALL_TREE + "/", util.getSysroot() ] try: rc = util.execWithRedirect(cmd, args) except (OSError, RuntimeError) as e: msg = None err = str(e) log.error(err) else: err = None msg = "%s exited with code %d" % (cmd, rc) log.info(msg) if err or rc == 12: exn = PayloadInstallError(err or msg) if errorHandler.cb(exn) == ERROR_RAISE: raise exn # Wait for progress thread to finish with self.pct_lock: self.pct = 100 threadMgr.wait(THREAD_LIVE_PROGRESS) # Live needs to create the rescue image before bootloader is written if not os.path.exists(util.getSysroot() + "/usr/sbin/new-kernel-pkg"): log.error( "new-kernel-pkg does not exist - grubby wasn't installed? skipping" ) return for kernel in self.kernelVersionList: log.info("Generating rescue image for %s", kernel) util.execInSysroot("new-kernel-pkg", ["--rpmposttrans", kernel])
def _run(self, cmd, args, required=True): if not os.path.lexists(conf.target.system_root + cmd): if required: msg = _("%s is missing. Cannot setup authentication.") % cmd raise KickstartError(msg) else: return try: util.execInSysroot(cmd, args) except RuntimeError as msg: authselect_log.error("Error running %s %s: %s", cmd, args, msg)
def install(self): """ Install the payload if it is a tar. Otherwise fall back to rsync of INSTALL_TREE """ # If it doesn't look like a tarfile use the super's install() if not self.is_tarfile: super().install() return # Use 2x the archive's size to estimate the size of the install # This is used to drive the progress display self.source_size = os.stat(self.image_path)[stat.ST_SIZE] * 2 self.pct_lock = Lock() self.pct = 0 threadMgr.add( AnacondaThread(name=THREAD_LIVE_PROGRESS, target=self.progress)) cmd = "tar" # preserve: ACL's, xattrs, and SELinux context args = [ "--selinux", "--acls", "--xattrs", "--xattrs-include", "*", "--exclude", "/dev/", "--exclude", "/proc/", "--exclude", "/sys/", "--exclude", "/run/", "--exclude", "/boot/*rescue*", "--exclude", "/etc/machine-id", "-xaf", self.image_path, "-C", util.getSysroot() ] try: rc = util.execWithRedirect(cmd, args) except (OSError, RuntimeError) as e: msg = None err = str(e) log.error(err) else: err = None msg = "%s exited with code %d" % (cmd, rc) log.info(msg) if err: exn = PayloadInstallError(err or msg) if errorHandler.cb(exn) == ERROR_RAISE: raise exn # Wait for progress thread to finish with self.pct_lock: self.pct = 100 threadMgr.wait(THREAD_LIVE_PROGRESS) # Live needs to create the rescue image before bootloader is written for kernel in self.kernelVersionList: log.info("Generating rescue image for %s", kernel) util.execInSysroot("new-kernel-pkg", ["--rpmposttrans", kernel])
def install(self): """ Install the payload if it is a tar. Otherwise fall back to rsync of INSTALL_TREE """ # If it doesn't look like a tarfile use the super's install() if not self.is_tarfile: super().install() return # Use 2x the archive's size to estimate the size of the install # This is used to drive the progress display self.source_size = os.stat(self.image_path)[stat.ST_SIZE] * 2 self.pct_lock = Lock() self.pct = 0 threadMgr.add(AnacondaThread(name=THREAD_LIVE_PROGRESS, target=self.progress)) cmd = "tar" # preserve: ACL's, xattrs, and SELinux context args = ["--selinux", "--acls", "--xattrs", "--xattrs-include", "*", "--exclude", "/dev/", "--exclude", "/proc/", "--exclude", "/sys/", "--exclude", "/run/", "--exclude", "/boot/*rescue*", "--exclude", "/etc/machine-id", "-xaf", self.image_path, "-C", util.getSysroot()] try: rc = util.execWithRedirect(cmd, args) except (OSError, RuntimeError) as e: msg = None err = str(e) log.error(err) else: err = None msg = "%s exited with code %d" % (cmd, rc) log.info(msg) if err: exn = PayloadInstallError(err or msg) if errorHandler.cb(exn) == ERROR_RAISE: raise exn # Wait for progress thread to finish with self.pct_lock: self.pct = 100 threadMgr.wait(THREAD_LIVE_PROGRESS) # Live needs to create the rescue image before bootloader is written for kernel in self.kernel_version_list: log.info("Generating rescue image for %s", kernel) util.execInSysroot("new-kernel-pkg", ["--rpmposttrans", kernel])
def recreate_initrds(self): """Recreate the initrds by calling new-kernel-pkg or dracut This needs to be done after all configuration files have been written, since dracut depends on some of them. :returns: None """ if os.path.exists(conf.target.system_root + "/usr/sbin/new-kernel-pkg"): use_dracut = False else: log.warning( "new-kernel-pkg does not exist - grubby wasn't installed? " " using dracut instead.") use_dracut = True for kernel in self.kernel_version_list: log.info("recreating initrd for %s", kernel) if not conf.target.is_image: if use_dracut: util.execInSysroot("depmod", ["-a", kernel]) util.execInSysroot( "dracut", ["-f", "/boot/initramfs-%s.img" % kernel, kernel]) else: util.execInSysroot("new-kernel-pkg", [ "--mkinitrd", "--dracut", "--depmod", "--update", kernel ]) # if the installation is running in fips mode then make sure # fips is also correctly enabled in the installed system if kernel_arguments.get("fips") == "1": # We use the --no-bootcfg option as we don't want fips-mode-setup to # modify the bootloader configuration. # Anaconda already does everything needed & it would require grubby to # be available on the system. util.execInSysroot("fips-mode-setup", ["--enable", "--no-bootcfg"]) else: # hostonly is not sensible for disk image installations # using /dev/disk/by-uuid/ is necessary due to disk image naming util.execInSysroot("dracut", [ "-N", "--persistent-policy", "by-uuid", "-f", "/boot/initramfs-%s.img" % kernel, kernel ])
def run(self): args = [] # If --use-system-defaults was passed then the user wants # whatever was provided by the rpms or ostree to be the # default, do nothing. if self._firewall_mode == FirewallMode.USE_SYSTEM_DEFAULTS: log.info( "ks file instructs to use system defaults for firewall, skipping configuration." ) return # enabled is None if neither --enable or --disable is passed # default to enabled if nothing has been set. if self._firewall_mode == FirewallMode.DISABLED: args += ["--disabled"] else: args += ["--enabled"] ssh_service_not_enabled = "ssh" not in self._enabled_services ssh_service_not_disabled = "ssh" not in self._disabled_services ssh_port_not_enabled = "22:tcp" not in self._enabled_ports # always enable SSH unless the service is explicitely disabled if ssh_service_not_enabled and ssh_service_not_disabled and ssh_port_not_enabled: args += ["--service=ssh"] for dev in self._trusts: args += ["--trust=%s" % (dev, )] for port in self._enabled_ports: args += ["--port=%s" % (port, )] for remove_service in self._disabled_services: args += ["--remove-service=%s" % (remove_service, )] for service in self._enabled_services: args += ["--service=%s" % (service, )] if not os.path.exists(self._sysroot + self.FIREWALL_OFFLINE_CMD): if self._firewall_mode == FirewallMode.ENABLED: msg = _("%s is missing. Cannot setup firewall.") % ( self.FIREWALL_OFFLINE_CMD, ) raise FirewallConfigurationError(msg) else: util.execInSysroot(self.FIREWALL_OFFLINE_CMD, args, root=self._sysroot)
def run(self): """Run the task.""" target_content_dir = utils.join_paths(self._sysroot, self._target_directory) utils.ensure_dir_exists(target_content_dir) if self._policy_data.content_type == "scap-security-guide": pass # nothing needed elif self._policy_data.content_type == "datastream": shutil.copy2(self._content_path, target_content_dir) elif self._policy_data.content_type == "rpm": # copy the RPM to the target system shutil.copy2(self._file_path, target_content_dir) # get the path of the RPM content_name = common.get_content_name(self._policy_data) package_path = utils.join_paths(self._target_directory, content_name) # and install it with yum ret = util.execInSysroot( "yum", ["-y", "--nogpg", "install", package_path]) if ret != 0: msg = _(f"Failed to install content RPM to the target system.") terminate(msg) return else: pattern = utils.join_paths(common.INSTALLATION_CONTENT_DIR, "*") utils.universal_copy(pattern, target_content_dir) if os.path.exists(self._tailoring_path): shutil.copy2(self._tailoring_path, target_content_dir)
def postInstall(self): """ Perform post-installation tasks. """ progressQ.send_message(_("Performing post-installation setup tasks")) blivet.util.umount(INSTALL_TREE) super().postInstall() # Make sure the new system has a machine-id, it won't boot without it # (and nor will some of the subsequent commands) if not os.path.exists(util.getSysroot() + "/etc/machine-id"): log.info("Generating machine ID") util.execInSysroot("systemd-machine-id-setup", []) for kernel in self.kernelVersionList: if flags.blscfg: log.info("Regenerating BLS info for %s", kernel) util.execInSysroot("kernel-install", ["add", kernel, "/lib/modules/{0}/vmlinuz".format(kernel)])
def execute(self): args = [] firewall_proxy = NETWORK.get_proxy(FIREWALL) # If --use-system-defaults was passed then the user wants # whatever was provided by the rpms or ostree to be the # default, do nothing. if firewall_proxy.FirewallMode == FIREWALL_USE_SYSTEM_DEFAULTS: firewall_log.info("ks file instructs to use system defaults for " "firewall, skipping configuration.") return # enabled is None if neither --enable or --disable is passed # default to enabled if nothing has been set. if firewall_proxy.FirewallMode == FIREWALL_DISABLED: args += ["--disabled"] else: args += ["--enabled"] ssh_service_not_enabled = "ssh" not in firewall_proxy.EnabledServices ssh_service_not_disabled = "ssh" not in firewall_proxy.DisabledServices ssh_port_not_enabled = "22:tcp" not in firewall_proxy.EnabledPorts # always enable SSH unless the service is explicitely disabled if ssh_service_not_enabled and ssh_service_not_disabled and ssh_port_not_enabled: args += ["--service=ssh"] for dev in firewall_proxy.Trusts: args += ["--trust=%s" % (dev, )] for port in firewall_proxy.EnabledPorts: args += ["--port=%s" % (port, )] for remove_service in firewall_proxy.DisabledServices: args += ["--remove-service=%s" % (remove_service, )] for service in firewall_proxy.EnabledServices: args += ["--service=%s" % (service, )] cmd = "/usr/bin/firewall-offline-cmd" if not os.path.exists(util.getSysroot() + cmd): if firewall_proxy.FirewallMode == FIREWALL_ENABLED: msg = _("%s is missing. Cannot setup firewall.") % (cmd, ) raise KickstartError(msg) else: util.execInSysroot(cmd, args)
def recreate_initrds(self): """Recreate the initrds by calling new-kernel-pkg or dracut This needs to be done after all configuration files have been written, since dracut depends on some of them. :returns: None """ if os.path.exists(util.getSysroot() + "/usr/sbin/new-kernel-pkg"): use_dracut = False else: log.warning("new-kernel-pkg does not exist - grubby wasn't installed? " " using dracut instead.") use_dracut = True for kernel in self.kernel_version_list: log.info("recreating initrd for %s", kernel) if not conf.target.is_image: if use_dracut: util.execInSysroot("depmod", ["-a", kernel]) util.execInSysroot("dracut", ["-f", "/boot/initramfs-%s.img" % kernel, kernel]) else: util.execInSysroot("new-kernel-pkg", ["--mkinitrd", "--dracut", "--depmod", "--update", kernel]) # if the installation is running in fips mode then make sure # fips is also correctly enabled in the installed system if flags.cmdline.get("fips") == "1": # We use the --no-bootcfg option as we don't want fips-mode-setup to # modify the bootloader configuration. # Anaconda already does everything needed & it would require grubby to # be available on the system. util.execInSysroot("fips-mode-setup", ["--enable", "--no-bootcfg"]) else: # hostonly is not sensible for disk image installations # using /dev/disk/by-uuid/ is necessary due to disk image naming util.execInSysroot("dracut", ["-N", "--persistent-policy", "by-uuid", "-f", "/boot/initramfs-%s.img" % kernel, kernel])
def run(self): """Run the task.""" if not arch.is_s390(): log.debug("ZIPL can be run only on s390x.") return if conf.target.is_directory: log.debug( "The bootloader installation is disabled for dir installations." ) return if self._mode == BootloaderMode.DISABLED: log.debug("The bootloader installation is disabled.") return execInSysroot("zipl", [])
def execute(self): args = [] firewall_proxy = NETWORK.get_proxy(FIREWALL) # If --use-system-defaults was passed then the user wants # whatever was provided by the rpms or ostree to be the # default, do nothing. if firewall_proxy.FirewallMode == FIREWALL_USE_SYSTEM_DEFAULTS: firewall_log.info("ks file instructs to use system defaults for " "firewall, skipping configuration.") return # enabled is None if neither --enable or --disable is passed # default to enabled if nothing has been set. if firewall_proxy.FirewallMode == FIREWALL_DISABLED: args += ["--disabled"] else: args += ["--enabled"] ssh_service_not_enabled = "ssh" not in firewall_proxy.EnabledServices ssh_service_not_disabled = "ssh" not in firewall_proxy.DisabledServices ssh_port_not_enabled = "22:tcp" not in firewall_proxy.EnabledPorts # always enable SSH unless the service is explicitely disabled if ssh_service_not_enabled and ssh_service_not_disabled and ssh_port_not_enabled: args += ["--service=ssh"] for dev in firewall_proxy.Trusts: args += ["--trust=%s" % (dev,)] for port in firewall_proxy.EnabledPorts: args += ["--port=%s" % (port,)] for remove_service in firewall_proxy.DisabledServices: args += ["--remove-service=%s" % (remove_service,)] for service in firewall_proxy.EnabledServices: args += ["--service=%s" % (service,)] cmd = "/usr/bin/firewall-offline-cmd" if not os.path.exists(util.getSysroot() + cmd): if firewall_proxy.FirewallMode == FIREWALL_ENABLED: msg = _("%s is missing. Cannot setup firewall.") % (cmd,) raise KickstartError(msg) else: util.execInSysroot(cmd, args)
def write_config(self): self.write_config_console(None) # See if we have a password and if so update the boot args before we # write out the defaults file. if self.password or self.encrypted_password: self.boot_args.add("rd.shell=0") self.write_defaults() # if we fail to setup password auth we should complete the # installation so the system is at least bootable try: self.write_password_config() except (BootLoaderError, OSError, RuntimeError) as e: log.error("boot loader password setup failed: %s", e) # make sure the default entry is the OS we are installing if self.default is not None: machine_id_path = conf.target.system_root + "/etc/machine-id" if not os.access(machine_id_path, os.R_OK): log.error("failed to read machine-id, default entry not set") return with open(machine_id_path, "r") as fd: machine_id = fd.readline().strip() default_entry = "%s-%s" % (machine_id, self.default.version) rc = util.execInSysroot("grub2-set-default", [default_entry]) if rc: log.error("failed to set default menu entry to %s", productName) # set menu_auto_hide grubenv variable if we should enable menu_auto_hide # set boot_success so that the menu is hidden on the boot after install if conf.bootloader.menu_auto_hide: rc = util.execInSysroot( "grub2-editenv", ["-", "set", "menu_auto_hide=1", "boot_success=1"]) if rc: log.error("failed to set menu_auto_hide=1") # now tell grub2 to generate the main configuration file rc = util.execInSysroot("grub2-mkconfig", ["-o", self.config_file]) if rc: raise BootLoaderError("failed to write boot loader configuration")
def write_config(self): self.write_config_console(None) # See if we have a password and if so update the boot args before we # write out the defaults file. if self.password or self.encrypted_password: self.boot_args.add("rd.shell=0") self.write_defaults() # if we fail to setup password auth we should complete the # installation so the system is at least bootable try: self.write_password_config() except (BootLoaderError, OSError, RuntimeError) as e: log.error("boot loader password setup failed: %s", e) # make sure the default entry is the OS we are installing if self.default is not None: machine_id_path = util.getSysroot() + "/etc/machine-id" if not os.access(machine_id_path, os.R_OK): log.error("failed to read machine-id, default entry not set") return with open(machine_id_path, "r") as fd: machine_id = fd.readline().strip() default_entry = "%s-%s" % (machine_id, self.default.version) rc = util.execInSysroot("grub2-set-default", [default_entry]) if rc: log.error("failed to set default menu entry to %s", productName) # set menu_auto_hide grubenv variable if we should enable menu_auto_hide # set boot_success so that the menu is hidden on the boot after install if conf.bootloader.menu_auto_hide: rc = util.execInSysroot("grub2-editenv", ["-", "set", "menu_auto_hide=1", "boot_success=1"]) if rc: log.error("failed to set menu_auto_hide=1") # now tell grub2 to generate the main configuration file rc = util.execInSysroot("grub2-mkconfig", ["-o", self.config_file]) if rc: raise BootLoaderError("failed to write boot loader configuration")
def postInstall(self): """ Perform post-installation tasks. """ progressQ.send_message(_("Performing post-installation setup tasks")) blivet.util.umount(INSTALL_TREE) super().postInstall() # Make sure the new system has a machine-id, it won't boot without it # (and nor will some of the subsequent commands) if not os.path.exists(util.getSysroot() + "/etc/machine-id"): log.info("Generating machine ID") util.execInSysroot("systemd-machine-id-setup", []) for kernel in self.kernelVersionList: if flags.blscfg: log.info("Regenerating BLS info for %s", kernel) util.execInSysroot( "kernel-install", ["add", kernel, "/lib/modules/{0}/vmlinuz".format(kernel)])
def post_install(self): """ Perform post-installation tasks. """ progressQ.send_message(_("Performing post-installation setup tasks")) payload_utils.unmount(INSTALL_TREE, raise_exc=True) super().post_install() # Make sure the new system has a machine-id, it won't boot without it # (and nor will some of the subsequent commands) if not os.path.exists(util.getSysroot() + "/etc/machine-id"): log.info("Generating machine ID") util.execInSysroot("systemd-machine-id-setup", []) for kernel in self.kernel_version_list: if not os.path.exists(util.getSysroot() + "/usr/sbin/new-kernel-pkg"): log.info("Regenerating BLS info for %s", kernel) util.execInSysroot("kernel-install", ["add", kernel, "/lib/modules/{0}/vmlinuz".format(kernel)])
def post_install(self): """ Perform post-installation tasks. """ progressQ.send_message(_("Performing post-installation setup tasks")) payload_utils.unmount(INSTALL_TREE, raise_exc=True) super().post_install() # Not using BLS configuration, skip it if os.path.exists(conf.target.system_root + "/usr/sbin/new-kernel-pkg"): return # Remove any existing BLS entries, they will not match the new system's # machine-id or /boot mountpoint. for file in glob.glob(conf.target.system_root + "/boot/loader/entries/*.conf"): log.info("Removing old BLS entry: %s", file) os.unlink(file) # Create new BLS entries for this system for kernel in self.kernel_version_list: log.info("Regenerating BLS info for %s", kernel) util.execInSysroot( "kernel-install", ["add", kernel, "/lib/modules/{0}/vmlinuz".format(kernel)]) # Update the bootloader configuration to make sure that the BLS # entries will have the correct kernel cmdline and not the value # taken from /proc/cmdline, that is used to boot the live image. bootloader = STORAGE.get_proxy(BOOTLOADER) if bootloader.IsEFI(): grub_cfg_path = "/etc/grub2-efi.cfg" else: grub_cfg_path = "/etc/grub2.cfg" # TODO: add a method to the bootloader interface that updates the # configuration and avoid having bootloader specific logic here. rc = util.execInSysroot("grub2-mkconfig", ["-o", grub_cfg_path]) if rc: raise BootloaderInstallationError( "failed to write boot loader configuration")
def _create_rescue_image(self): """Create the rescue initrd images for each installed kernel. """ # Always make sure the new system has a new machine-id, it won't boot without it # (and nor will some of the subsequent commands like grub2-mkconfig and kernel-install) log.info("Generating machine ID") if os.path.exists(conf.target.system_root + "/etc/machine-id"): os.unlink(conf.target.system_root + "/etc/machine-id") util.execInSysroot("systemd-machine-id-setup", []) if os.path.exists(conf.target.system_root + "/usr/sbin/new-kernel-pkg"): use_nkp = True else: log.debug( "new-kernel-pkg does not exist, calling scripts directly.") use_nkp = False for kernel in self.kernel_version_list: log.info("Generating rescue image for %s", kernel) if use_nkp: util.execInSysroot("new-kernel-pkg", ["--rpmposttrans", kernel]) else: files = glob.glob(conf.target.system_root + "/etc/kernel/postinst.d/*") srlen = len(conf.target.system_root) files = sorted( [f[srlen:] for f in files if os.access(f, os.X_OK)]) for file in files: util.execInSysroot( file, [kernel, "/boot/vmlinuz-%s" % kernel])
def execute(self, storage, ksdata, users, payload): """ The execute method that should make changes to the installed system. It is called only once in the post-install setup phase. :see: setup :param users: information about created users :type users: pyanaconda.users.Users instance """ if self.dry_run or not self.profile_id: # nothing more to be done in the dry-run mode or if no profile is # selected return target_content_dir = utils.join_paths(conf.target.system_root, common.TARGET_CONTENT_DIR) utils.ensure_dir_exists(target_content_dir) if self.content_type == "datastream": shutil.copy2(self.preinst_content_path, target_content_dir) elif self.content_type == "rpm": # copy the RPM to the target system shutil.copy2(self.raw_preinst_content_path, target_content_dir) # and install it with yum ret = util.execInSysroot( "yum", ["-y", "--nogpg", "install", self.raw_postinst_content_path]) if ret != 0: raise common.ExtractionError("Failed to install content " "RPM to the target system") elif self.content_type == "scap-security-guide": # nothing needed pass else: utils.universal_copy( utils.join_paths(common.INSTALLATION_CONTENT_DIR, "*"), target_content_dir) if os.path.exists(self.preinst_tailoring_path): shutil.copy2(self.preinst_tailoring_path, target_content_dir) common.run_oscap_remediate(self.profile_id, self.postinst_content_path, self.datastream_id, self.xccdf_id, self.postinst_tailoring_path, chroot=conf.target.system_root)
def execute(self, storage, ksdata, users, payload): """ The execute method that should make changes to the installed system. It is called only once in the post-install setup phase. :see: setup :param users: information about created users :type users: pyanaconda.users.Users instance """ if self.dry_run or not self.profile_id: # nothing more to be done in the dry-run mode or if no profile is # selected return target_content_dir = utils.join_paths(getSysroot(), common.TARGET_CONTENT_DIR) utils.ensure_dir_exists(target_content_dir) if self.content_type == "datastream": shutil.copy2(self.preinst_content_path, target_content_dir) elif self.content_type == "rpm": # copy the RPM to the target system shutil.copy2(self.raw_preinst_content_path, target_content_dir) # and install it with yum ret = util.execInSysroot("yum", ["-y", "--nogpg", "install", self.raw_postinst_content_path]) if ret != 0: raise common.ExtractionError("Failed to install content " "RPM to the target system") elif self.content_type == "scap-security-guide": # nothing needed pass else: utils.universal_copy(utils.join_paths(common.INSTALLATION_CONTENT_DIR, "*"), target_content_dir) if os.path.exists(self.preinst_tailoring_path): shutil.copy2(self.preinst_tailoring_path, target_content_dir) common.run_oscap_remediate(self.profile_id, self.postinst_content_path, self.datastream_id, self.xccdf_id, self.postinst_tailoring_path, chroot=getSysroot())
def mactel_config(self): if os.path.exists(util.getSysroot() + "/usr/libexec/mactel-boot-setup"): rc = util.execInSysroot("/usr/libexec/mactel-boot-setup", []) if rc: log.error("failed to configure Mac boot loader")
def doConfiguration(storage, payload, ksdata): """Configure the installed system.""" configuration_queue = TaskQueue("Configuration queue") # connect progress reporting configuration_queue.queue_started.connect(lambda x: progress_message(x.status_message)) configuration_queue.task_completed.connect(lambda x: progress_step(x.name)) # schedule the execute methods of ksdata that require an installed system to be present os_config = TaskQueue("Installed system configuration", N_("Configuring installed system")) os_config.append(Task("Configure authselect", ksdata.authselect.execute)) os_config.append(Task("Configure SELinux", ksdata.selinux.execute)) os_config.append(Task("Configure first boot tasks", ksdata.firstboot.execute)) os_config.append(Task("Configure services", ksdata.services.execute)) os_config.append(Task("Configure keyboard", ksdata.keyboard.execute)) os_config.append(Task("Configure timezone", ksdata.timezone.execute)) os_config.append(Task("Configure language", ksdata.lang.execute)) os_config.append(Task("Configure firewall", ksdata.firewall.execute)) os_config.append(Task("Configure X", ksdata.xconfig.execute)) configuration_queue.append(os_config) # schedule network configuration (if required) if conf.system.provides_network_config: network_config = TaskQueue("Network configuration", N_("Writing network configuration")) network_config.append(Task("Network configuration", ksdata.network.execute, (payload, ))) configuration_queue.append(network_config) # creating users and groups requires some pre-configuration. u = Users() user_config = TaskQueue("User creation", N_("Creating users")) user_config.append(Task("Configure root", ksdata.rootpw.execute, (storage, ksdata, u))) user_config.append(Task("Configure user groups", ksdata.group.execute, (storage, ksdata, u))) user_config.append(Task("Configure user", ksdata.user.execute, (storage, ksdata, u))) user_config.append(Task("Configure SSH key", ksdata.sshkey.execute, (storage, ksdata, u))) configuration_queue.append(user_config) # Anaconda addon configuration addon_config = TaskQueue("Anaconda addon configuration", N_("Configuring addons")) addon_config.append(Task("Configure Anaconda addons", ksdata.addons.execute, (storage, ksdata, u, payload))) configuration_queue.append(addon_config) # Initramfs generation generate_initramfs = TaskQueue("Initramfs generation", N_("Generating initramfs")) generate_initramfs.append(Task("Generate initramfs", payload.recreate_initrds)) # This works around 2 problems, /boot on BTRFS and BTRFS installations where the initrd is # recreated after the first writeBootLoader call. This reruns it after the new initrd has # been created, fixing the kernel root and subvol args and adding the missing initrd entry. boot_on_btrfs = isinstance(storage.mountpoints.get("/"), BTRFSDevice) bootloader_proxy = STORAGE.get_proxy(BOOTLOADER) bootloader_enabled = bootloader_proxy.BootloaderMode != BOOTLOADER_DISABLED if isinstance(payload, LiveImagePayload) and boot_on_btrfs and bootloader_enabled: generate_initramfs.append(Task("Write BTRFS bootloader fix", write_boot_loader, (storage, payload))) # Invoking zipl should be the last thing done on a s390x installation (see #1652727). if arch.is_s390() and not conf.target.is_directory and bootloader_enabled: generate_initramfs.append(Task("Rerun zipl", lambda: util.execInSysroot("zipl", []))) configuration_queue.append(generate_initramfs) # join a realm (if required) if ksdata.realm.discovered: join_realm = TaskQueue("Realm join", N_("Joining realm: %s") % ksdata.realm.discovered) join_realm.append(Task("Join a realm", ksdata.realm.execute)) configuration_queue.append(join_realm) post_scripts = TaskQueue("Post installation scripts", N_("Running post-installation scripts")) post_scripts.append(Task("Run post installation scripts", runPostScripts, (ksdata.scripts,))) configuration_queue.append(post_scripts) # setup kexec reboot if requested if flags.flags.kexec: kexec_setup = TaskQueue("Kexec setup", N_("Setting up kexec")) kexec_setup.append(Task("Setup kexec", setup_kexec)) configuration_queue.append(kexec_setup) # write anaconda related configs & kickstarts write_configs = TaskQueue("Write configs and kickstarts", N_("Storing configuration files and kickstarts")) # Write the kickstart file to the installed system (or, copy the input # kickstart file over if one exists). if flags.flags.nosave_output_ks: # don't write the kickstart file to the installed system if this has # been disabled by the nosave option log.warning("Writing of the output kickstart to installed system has been disabled" " by the nosave option.") else: # write anaconda related configs & kickstarts write_configs.append(Task("Store kickstarts", _writeKS, (ksdata,))) # Write out the user interaction config file. # # But make sure it's not written out in the image and directory installation mode, # as that might result in spokes being inadvertently hidden when the actual installation # starts from the generate image or directory contents. if conf.target.is_image: log.info("Not writing out user interaction config file due to image install mode.") elif conf.target.is_directory: log.info("Not writing out user interaction config file due to directory install mode.") else: write_configs.append(Task("Store user interaction config", screen_access.sam.write_out_config_file)) # only add write_configs to the main queue if we actually store some kickstarts/configs if write_configs.task_count: configuration_queue.append(write_configs) # notify progress tracking about the number of steps progress_init(configuration_queue.task_count) # log contents of the main task queue log.info(configuration_queue.summary) # log tasks and queues when they are started # - note that we are using generators to add the counter queue_counter = util.item_counter(configuration_queue.queue_count) task_started_counter = util.item_counter(configuration_queue.task_count) task_completed_counter = util.item_counter(configuration_queue.task_count) configuration_queue.queue_started.connect(lambda x: log.info("Queue started: %s (%s)", x.name, next(queue_counter))) configuration_queue.task_started.connect(lambda x: log.info("Task started: %s (%s)", x.name, next(task_started_counter))) configuration_queue.task_completed.connect(lambda x: log.debug("Task completed: %s (%s) (%1.1f s)", x.name, next(task_completed_counter), x.elapsed_time)) # start the task queue configuration_queue.start() # done progress_complete()
def install(self, args=None): args = ["--install", self._config_dir] rc = util.execInSysroot("extlinux", args) if rc: raise BootLoaderError("boot loader install failed")
def doConfiguration(storage, payload, ksdata): """Configure the installed system.""" configuration_queue = TaskQueue("Configuration queue") # connect progress reporting configuration_queue.queue_started.connect( lambda x: progress_message(x.status_message)) configuration_queue.task_completed.connect(lambda x: progress_step(x.name)) # schedule the execute methods of ksdata that require an installed system to be present os_config = TaskQueue("Installed system configuration", N_("Configuring installed system")) os_config.append(Task("Configure authselect", ksdata.authselect.execute)) security_proxy = SECURITY.get_proxy() security_dbus_tasks = security_proxy.InstallWithTasks(util.getSysroot()) # add one Task instance per DBUS task for dbus_task in security_dbus_tasks: task_proxy = SECURITY.get_proxy(dbus_task) os_config.append(Task(task_proxy.Name, sync_run_task, (task_proxy, ))) services_proxy = SERVICES.get_proxy() services_dbus_tasks = services_proxy.InstallWithTasks(util.getSysroot()) # add one Task instance per DBUS task for dbus_task in services_dbus_tasks: task_proxy = SERVICES.get_proxy(dbus_task) os_config.append(Task(task_proxy.Name, sync_run_task, (task_proxy, ))) os_config.append(Task("Configure keyboard", ksdata.keyboard.execute)) os_config.append(Task("Configure timezone", ksdata.timezone.execute)) localization_proxy = LOCALIZATION.get_proxy() localization_dbus_tasks = localization_proxy.InstallWithTasks( util.getSysroot()) # add one Task instance per DBUS task for dbus_task in localization_dbus_tasks: task_proxy = LOCALIZATION.get_proxy(dbus_task) os_config.append(Task(task_proxy.Name, sync_run_task, (task_proxy, ))) firewall_proxy = NETWORK.get_proxy(FIREWALL) firewall_dbus_task = firewall_proxy.InstallWithTask(util.getSysroot()) task_proxy = NETWORK.get_proxy(firewall_dbus_task) os_config.append(Task(task_proxy.Name, sync_run_task, (task_proxy, ))) configuration_queue.append(os_config) # schedule network configuration (if required) if conf.system.provides_network_config: network_config = TaskQueue("Network configuration", N_("Writing network configuration")) network_config.append( Task("Network configuration", ksdata.network.execute, (payload, ))) configuration_queue.append(network_config) # creating users and groups requires some pre-configuration. user_config = TaskQueue("User creation", N_("Creating users")) users_proxy = USERS.get_proxy() users_dbus_tasks = users_proxy.InstallWithTasks(util.getSysroot()) # add one Task instance per DBUS task for dbus_task in users_dbus_tasks: task_proxy = USERS.get_proxy(dbus_task) user_config.append(Task(task_proxy.Name, sync_run_task, (task_proxy, ))) configuration_queue.append(user_config) # Anaconda addon configuration addon_config = TaskQueue("Anaconda addon configuration", N_("Configuring addons")) # there is no longer a User class & addons should no longer need it # FIXME: drop user class parameter from the API & all known addons addon_config.append( Task("Configure Anaconda addons", ksdata.addons.execute, (storage, ksdata, None, payload))) configuration_queue.append(addon_config) # Initramfs generation generate_initramfs = TaskQueue("Initramfs generation", N_("Generating initramfs")) generate_initramfs.append( Task("Generate initramfs", payload.recreate_initrds)) # This works around 2 problems, /boot on BTRFS and BTRFS installations where the initrd is # recreated after the first writeBootLoader call. This reruns it after the new initrd has # been created, fixing the kernel root and subvol args and adding the missing initrd entry. boot_on_btrfs = isinstance(storage.mountpoints.get("/"), BTRFSDevice) bootloader_proxy = STORAGE.get_proxy(BOOTLOADER) bootloader_enabled = bootloader_proxy.BootloaderMode != BOOTLOADER_DISABLED if isinstance(payload, LiveImagePayload) and boot_on_btrfs and bootloader_enabled: generate_initramfs.append( Task("Write BTRFS bootloader fix", write_boot_loader, (storage, payload))) # Invoking zipl should be the last thing done on a s390x installation (see #1652727). if arch.is_s390() and not conf.target.is_directory and bootloader_enabled: generate_initramfs.append( Task("Rerun zipl", lambda: util.execInSysroot("zipl", []))) configuration_queue.append(generate_initramfs) # join a realm (if required) if ksdata.realm.discovered: join_realm = TaskQueue( "Realm join", N_("Joining realm: %s") % ksdata.realm.discovered) join_realm.append(Task("Join a realm", ksdata.realm.execute)) configuration_queue.append(join_realm) post_scripts = TaskQueue("Post installation scripts", N_("Running post-installation scripts")) post_scripts.append( Task("Run post installation scripts", runPostScripts, (ksdata.scripts, ))) configuration_queue.append(post_scripts) # setup kexec reboot if requested if flags.flags.kexec: kexec_setup = TaskQueue("Kexec setup", N_("Setting up kexec")) kexec_setup.append(Task("Setup kexec", setup_kexec)) configuration_queue.append(kexec_setup) # write anaconda related configs & kickstarts write_configs = TaskQueue("Write configs and kickstarts", N_("Storing configuration files and kickstarts")) # Write the kickstart file to the installed system (or, copy the input # kickstart file over if one exists). if flags.flags.nosave_output_ks: # don't write the kickstart file to the installed system if this has # been disabled by the nosave option log.warning( "Writing of the output kickstart to installed system has been disabled" " by the nosave option.") else: # write anaconda related configs & kickstarts write_configs.append(Task("Store kickstarts", _writeKS, (ksdata, ))) # only add write_configs to the main queue if we actually store some kickstarts/configs if write_configs.task_count: configuration_queue.append(write_configs) # notify progress tracking about the number of steps progress_init(configuration_queue.task_count) # log contents of the main task queue log.info(configuration_queue.summary) # log tasks and queues when they are started # - note that we are using generators to add the counter queue_counter = util.item_counter(configuration_queue.queue_count) task_started_counter = util.item_counter(configuration_queue.task_count) task_completed_counter = util.item_counter(configuration_queue.task_count) configuration_queue.queue_started.connect(lambda x: log.info( "Queue started: %s (%s)", x.name, next(queue_counter))) configuration_queue.task_started.connect(lambda x: log.info( "Task started: %s (%s)", x.name, next(task_started_counter))) configuration_queue.task_completed.connect( lambda x: log.debug("Task completed: %s (%s) (%1.1f s)", x.name, next(task_completed_counter), x.elapsed_time)) # start the task queue configuration_queue.start() # done progress_complete()
def install(self): """ Install the payload. """ if self.source_size <= 0: raise PayloadInstallError("Nothing to install") self.pct_lock = Lock() self.pct = 0 threadMgr.add(AnacondaThread(name=THREAD_LIVE_PROGRESS, target=self.progress)) cmd = "rsync" # preserve: permissions, owners, groups, ACL's, xattrs, times, # symlinks, hardlinks # go recursively, include devices and special files, don't cross # file system boundaries args = ["-pogAXtlHrDx", "--exclude", "/dev/", "--exclude", "/proc/", "--exclude", "/sys/", "--exclude", "/run/", "--exclude", "/boot/*rescue*", "--exclude", "/boot/loader/", "--exclude", "/boot/efi/loader/", "--exclude", "/etc/machine-id", INSTALL_TREE + "/", util.getSysroot()] try: rc = util.execWithRedirect(cmd, args) except (OSError, RuntimeError) as e: msg = None err = str(e) log.error(err) else: err = None msg = "%s exited with code %d" % (cmd, rc) log.info(msg) if err or rc == 11: exn = PayloadInstallError(err or msg) if errorHandler.cb(exn) == ERROR_RAISE: raise exn # Wait for progress thread to finish with self.pct_lock: self.pct = 100 threadMgr.wait(THREAD_LIVE_PROGRESS) # Live needs to create the rescue image before bootloader is written if os.path.exists(util.getSysroot() + "/usr/sbin/new-kernel-pkg"): use_nkp = True else: log.warning("new-kernel-pkg does not exist - grubby wasn't installed?") use_nkp = False for kernel in self.kernel_version_list: log.info("Generating rescue image for %s", kernel) if use_nkp: util.execInSysroot("new-kernel-pkg", ["--rpmposttrans", kernel]) else: files = glob.glob(util.getSysroot() + "/etc/kernel/postinst.d/*") srlen = len(util.getSysroot()) files = sorted([f[srlen:] for f in files if os.access(f, os.X_OK)]) for file in files: util.execInSysroot(file, [kernel, "/boot/vmlinuz-%s" % kernel])
def mactel_config(self): if os.path.exists(conf.target.system_root + "/usr/libexec/mactel-boot-setup"): rc = util.execInSysroot("/usr/libexec/mactel-boot-setup", []) if rc: log.error("failed to configure Mac boot loader")
def doConfiguration(storage, payload, ksdata): """Configure the installed system.""" configuration_queue = TaskQueue("Configuration queue") # connect progress reporting configuration_queue.queue_started.connect( lambda x: progress_message(x.status_message)) configuration_queue.task_completed.connect(lambda x: progress_step(x.name)) # schedule the execute methods of ksdata that require an installed system to be present os_config = TaskQueue("Installed system configuration", N_("Configuring installed system")) os_config.append(Task("Configure authselect", ksdata.authselect.execute)) os_config.append(Task("Configure SELinux", ksdata.selinux.execute)) os_config.append( Task("Configure first boot tasks", ksdata.firstboot.execute)) os_config.append(Task("Configure services", ksdata.services.execute)) os_config.append(Task("Configure keyboard", ksdata.keyboard.execute)) os_config.append(Task("Configure timezone", ksdata.timezone.execute)) os_config.append(Task("Configure language", ksdata.lang.execute)) os_config.append(Task("Configure firewall", ksdata.firewall.execute)) os_config.append(Task("Configure X", ksdata.xconfig.execute)) configuration_queue.append(os_config) # schedule network configuration (if required) if conf.system.provides_network_config: network_config = TaskQueue("Network configuration", N_("Writing network configuration")) network_config.append( Task("Network configuration", ksdata.network.execute, (payload, ))) configuration_queue.append(network_config) # creating users and groups requires some pre-configuration. u = Users() user_config = TaskQueue("User creation", N_("Creating users")) user_config.append( Task("Configure root", ksdata.rootpw.execute, (storage, ksdata, u))) user_config.append( Task("Configure user groups", ksdata.group.execute, (storage, ksdata, u))) user_config.append( Task("Configure user", ksdata.user.execute, (storage, ksdata, u))) user_config.append( Task("Configure SSH key", ksdata.sshkey.execute, (storage, ksdata, u))) configuration_queue.append(user_config) # Anaconda addon configuration addon_config = TaskQueue("Anaconda addon configuration", N_("Configuring addons")) addon_config.append( Task("Configure Anaconda addons", ksdata.addons.execute, (storage, ksdata, u, payload))) configuration_queue.append(addon_config) # Initramfs generation generate_initramfs = TaskQueue("Initramfs generation", N_("Generating initramfs")) generate_initramfs.append( Task("Generate initramfs", payload.recreate_initrds)) # This works around 2 problems, /boot on BTRFS and BTRFS installations where the initrd is # recreated after the first writeBootLoader call. This reruns it after the new initrd has # been created, fixing the kernel root and subvol args and adding the missing initrd entry. boot_on_btrfs = isinstance(storage.mountpoints.get("/"), BTRFSDevice) bootloader_proxy = STORAGE.get_proxy(BOOTLOADER) bootloader_enabled = bootloader_proxy.BootloaderMode != BOOTLOADER_DISABLED if isinstance(payload, LiveImagePayload) and boot_on_btrfs and bootloader_enabled: generate_initramfs.append( Task("Write BTRFS bootloader fix", write_boot_loader, (storage, payload))) # Invoking zipl should be the last thing done on a s390x installation (see #1652727). if arch.is_s390() and not conf.target.is_directory and bootloader_enabled: generate_initramfs.append( Task("Rerun zipl", lambda: util.execInSysroot("zipl", []))) configuration_queue.append(generate_initramfs) # join a realm (if required) if ksdata.realm.discovered: join_realm = TaskQueue( "Realm join", N_("Joining realm: %s") % ksdata.realm.discovered) join_realm.append(Task("Join a realm", ksdata.realm.execute)) configuration_queue.append(join_realm) post_scripts = TaskQueue("Post installation scripts", N_("Running post-installation scripts")) post_scripts.append( Task("Run post installation scripts", runPostScripts, (ksdata.scripts, ))) configuration_queue.append(post_scripts) # setup kexec reboot if requested if flags.flags.kexec: kexec_setup = TaskQueue("Kexec setup", N_("Setting up kexec")) kexec_setup.append(Task("Setup kexec", setup_kexec)) configuration_queue.append(kexec_setup) # write anaconda related configs & kickstarts write_configs = TaskQueue("Write configs and kickstarts", N_("Storing configuration files and kickstarts")) # Write the kickstart file to the installed system (or, copy the input # kickstart file over if one exists). if flags.flags.nosave_output_ks: # don't write the kickstart file to the installed system if this has # been disabled by the nosave option log.warning( "Writing of the output kickstart to installed system has been disabled" " by the nosave option.") else: # write anaconda related configs & kickstarts write_configs.append(Task("Store kickstarts", _writeKS, (ksdata, ))) # Write out the user interaction config file. # # But make sure it's not written out in the image and directory installation mode, # as that might result in spokes being inadvertently hidden when the actual installation # starts from the generate image or directory contents. if conf.target.is_image: log.info( "Not writing out user interaction config file due to image install mode." ) elif conf.target.is_directory: log.info( "Not writing out user interaction config file due to directory install mode." ) else: write_configs.append( Task("Store user interaction config", screen_access.sam.write_out_config_file)) # only add write_configs to the main queue if we actually store some kickstarts/configs if write_configs.task_count: configuration_queue.append(write_configs) # notify progress tracking about the number of steps progress_init(configuration_queue.task_count) # log contents of the main task queue log.info(configuration_queue.summary) # log tasks and queues when they are started # - note that we are using generators to add the counter queue_counter = util.item_counter(configuration_queue.queue_count) task_started_counter = util.item_counter(configuration_queue.task_count) task_completed_counter = util.item_counter(configuration_queue.task_count) configuration_queue.queue_started.connect(lambda x: log.info( "Queue started: %s (%s)", x.name, next(queue_counter))) configuration_queue.task_started.connect(lambda x: log.info( "Task started: %s (%s)", x.name, next(task_started_counter))) configuration_queue.task_completed.connect( lambda x: log.debug("Task completed: %s (%s) (%1.1f s)", x.name, next(task_completed_counter), x.elapsed_time)) # start the task queue configuration_queue.start() # done progress_complete()
def _prepare_configuration(storage, payload, ksdata): """Configure the installed system.""" configuration_queue = TaskQueue("Configuration queue") # connect progress reporting configuration_queue.queue_started.connect(lambda x: progress_message(x.status_message)) configuration_queue.task_completed.connect(lambda x: progress_step(x.name)) # schedule the execute methods of ksdata that require an installed system to be present os_config = TaskQueue("Installed system configuration", N_("Configuring installed system")) os_config.append(Task("Configure authselect", ksdata.authselect.execute)) # add installation tasks for the Security DBus module security_proxy = SECURITY.get_proxy() security_dbus_tasks = security_proxy.InstallWithTasks() os_config.append_dbus_tasks(SECURITY, security_dbus_tasks) # add installation tasks for the Services DBus module services_proxy = SERVICES.get_proxy() services_dbus_tasks = services_proxy.InstallWithTasks() os_config.append_dbus_tasks(SERVICES, services_dbus_tasks) os_config.append(Task("Configure keyboard", ksdata.keyboard.execute)) os_config.append(Task("Configure timezone", ksdata.timezone.execute)) # add installation tasks for the Localization DBus module localization_proxy = LOCALIZATION.get_proxy() localization_dbus_tasks = localization_proxy.InstallWithTasks() os_config.append_dbus_tasks(LOCALIZATION, localization_dbus_tasks) # add the Firewall configuration task firewall_proxy = NETWORK.get_proxy(FIREWALL) firewall_dbus_task = firewall_proxy.InstallWithTask() os_config.append_dbus_tasks(NETWORK, [firewall_dbus_task]) configuration_queue.append(os_config) # schedule network configuration (if required) if conf.system.provides_network_config: network_config = TaskQueue("Network configuration", N_("Writing network configuration")) network_config.append(Task("Network configuration", ksdata.network.execute, (payload, ))) configuration_queue.append(network_config) # add installation tasks for the Users DBus module user_config = TaskQueue("User creation", N_("Creating users")) users_proxy = USERS.get_proxy() users_dbus_tasks = users_proxy.InstallWithTasks() os_config.append_dbus_tasks(USERS, users_dbus_tasks) configuration_queue.append(user_config) # Anaconda addon configuration addon_config = TaskQueue("Anaconda addon configuration", N_("Configuring addons")) # there is no longer a User class & addons should no longer need it # FIXME: drop user class parameter from the API & all known addons addon_config.append(Task("Configure Anaconda addons", ksdata.addons.execute, (storage, ksdata, None, payload))) configuration_queue.append(addon_config) # Initramfs generation generate_initramfs = TaskQueue("Initramfs generation", N_("Generating initramfs")) generate_initramfs.append(Task("Generate initramfs", payload.recreate_initrds)) # This works around 2 problems, /boot on BTRFS and BTRFS installations where the initrd is # recreated after the first writeBootLoader call. This reruns it after the new initrd has # been created, fixing the kernel root and subvol args and adding the missing initrd entry. boot_on_btrfs = isinstance(storage.mountpoints.get("/"), BTRFSDevice) bootloader_proxy = STORAGE.get_proxy(BOOTLOADER) bootloader_enabled = bootloader_proxy.BootloaderMode != BOOTLOADER_DISABLED if isinstance(payload, LiveImagePayload) and boot_on_btrfs and bootloader_enabled: generate_initramfs.append(Task("Write BTRFS bootloader fix", write_boot_loader, (storage, payload))) # Invoking zipl should be the last thing done on a s390x installation (see #1652727). if arch.is_s390() and not conf.target.is_directory and bootloader_enabled: generate_initramfs.append(Task("Rerun zipl", lambda: util.execInSysroot("zipl", []))) configuration_queue.append(generate_initramfs) # realm join # - this can run only after network is configured in the target system chroot configuration_queue.append_dbus_tasks(SECURITY, [security_proxy.JoinRealmWithTask()]) post_scripts = TaskQueue("Post installation scripts", N_("Running post-installation scripts")) post_scripts.append(Task("Run post installation scripts", runPostScripts, (ksdata.scripts,))) configuration_queue.append(post_scripts) # setup kexec reboot if requested if flags.flags.kexec: kexec_setup = TaskQueue("Kexec setup", N_("Setting up kexec")) kexec_setup.append(Task("Setup kexec", setup_kexec)) configuration_queue.append(kexec_setup) # write anaconda related configs & kickstarts write_configs = TaskQueue("Write configs and kickstarts", N_("Storing configuration files and kickstarts")) # Write the kickstart file to the installed system (or, copy the input # kickstart file over if one exists). if flags.flags.nosave_output_ks: # don't write the kickstart file to the installed system if this has # been disabled by the nosave option log.warning("Writing of the output kickstart to installed system has been disabled" " by the nosave option.") else: # write anaconda related configs & kickstarts write_configs.append(Task("Store kickstarts", _writeKS, (ksdata,))) # only add write_configs to the main queue if we actually store some kickstarts/configs if write_configs.task_count: configuration_queue.append(write_configs) return configuration_queue