def run_installation(payload, ksdata): """Run the complete installation.""" queue = TaskQueue("Complete installation queue") queue.append(_prepare_installation(payload, ksdata)) queue.append(_prepare_configuration(payload, ksdata)) # notify progress tracking about the number of steps progress_init(queue.task_count) # log contents of the main task queue log.info(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(queue.queue_count) task_started_counter = util.item_counter(queue.task_count) task_completed_counter = util.item_counter(queue.task_count) queue.queue_started.connect(lambda x: log.info("Queue started: %s (%s)", x. name, next(queue_counter))) queue.task_started.connect(lambda x: log.info( "Task started: %s (%s)", x.name, next(task_started_counter))) 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 queue.start() # done progress_complete()
def _run_installation(self, payload, ksdata): """Run the complete installation.""" # before building the install task queue make # sure no backgrond processing threads are running and # the Anaconda internal state is thus final self._wait_for_threads_to_finish() queue = TaskQueue("Complete installation queue") queue.append(self._prepare_installation(payload, ksdata)) queue.append(self._prepare_configuration(payload, ksdata)) # Set the progress reporting callback of the payload class. # FIXME: This is a temporary workaround. payload._progress_cb = lambda step, msg: progress_message(msg) # Set the progress reporting callback of the DBus tasks. # FIXME: This is a temporary workaround. for item in queue.nested_items: if isinstance(item, DBusTask): item._progress_cb = lambda step, msg: progress_message(msg) # notify progress tracking about the number of steps progress_init(queue.task_count) # log contents of the main task queue log.info(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(queue.queue_count) task_started_counter = util.item_counter(queue.task_count) task_completed_counter = util.item_counter(queue.task_count) queue.queue_started.connect(lambda x: log.info( "Queue started: %s (%s)", x.name, next(queue_counter))) queue.task_started.connect(lambda x: log.info( "Task started: %s (%s)", x.name, next(task_started_counter))) 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 queue.start() # done progress_complete() # this message is automatically detected by QE tools, do not change it lightly log.info("All tasks in the installation queue are done. " "Installation successfully finished.")
def doConfiguration(storage, payload, ksdata, instClass): willWriteNetwork = not flags.flags.imageInstall and not flags.flags.dirInstall willRunRealmd = ksdata.realm.discovered # configure base, create users, configure addons, initramfs, post-install step_count = 5 # network, maybe if willWriteNetwork: step_count += 1 # if a realm was discovered, # increment the counter as the # real joining step will be executed if willRunRealmd: step_count += 1 progress_init(step_count) # Now run the execute methods of ksdata that require an installed system # to be present first. with progress_report(_("Configuring installed system")): ksdata.authconfig.execute(storage, ksdata, instClass) ksdata.selinux.execute(storage, ksdata, instClass) ksdata.firstboot.execute(storage, ksdata, instClass) ksdata.services.execute(storage, ksdata, instClass) ksdata.keyboard.execute(storage, ksdata, instClass) ksdata.timezone.execute(storage, ksdata, instClass) ksdata.lang.execute(storage, ksdata, instClass) ksdata.firewall.execute(storage, ksdata, instClass) ksdata.xconfig.execute(storage, ksdata, instClass) ksdata.skipx.execute(storage, ksdata, instClass) if willWriteNetwork: with progress_report(_("Writing network configuration")): ksdata.network.execute(storage, ksdata, instClass) # Creating users and groups requires some pre-configuration. with progress_report(_("Creating users")): createLuserConf(iutil.getSysroot(), algoname=getPassAlgo(ksdata.authconfig.authconfig)) u = Users() ksdata.rootpw.execute(storage, ksdata, instClass, u) ksdata.group.execute(storage, ksdata, instClass, u) ksdata.user.execute(storage, ksdata, instClass, u) ksdata.sshkey.execute(storage, ksdata, instClass, u) with progress_report(_("Configuring addons")): ksdata.addons.execute(storage, ksdata, instClass, u) with progress_report(_("Generating initramfs")): payload.recreateInitrds() # Work around rhbz#1200539, grubby doesn't handle grub2 missing initrd with /boot on btrfs # So rerun writing the bootloader if this is live and /boot is on btrfs boot_on_btrfs = isinstance( storage.mountpoints.get("/boot", storage.mountpoints.get("/")), BTRFSDevice) if flags.flags.livecdInstall and boot_on_btrfs \ and (not ksdata.bootloader.disabled and ksdata.bootloader != "none"): writeBootLoader(storage, payload, instClass, ksdata) if willRunRealmd: with progress_report(_("Joining realm: %s") % ksdata.realm.discovered): ksdata.realm.execute(storage, ksdata, instClass) with progress_report(_("Running post-installation scripts")): runPostScripts(ksdata.scripts) # setup kexec reboot if requested if flags.flags.kexec: setup_kexec() # Write the kickstart file to the installed system (or, copy the input # kickstart file over if one exists). _writeKS(ksdata) progress_complete()
def doInstall(storage, payload, ksdata, instClass): """Perform an installation. This method takes the ksdata as prepared by the UI (the first hub, in graphical mode) and applies it to the disk. The two main tasks for this are putting filesystems onto disks and installing packages onto those filesystems. """ willRunRealmd = ksdata.realm.join_realm willInstallBootloader = not flags.flags.dirInstall and ( not ksdata.bootloader.disabled and ksdata.bootloader != "none") # First save system time to HW clock. if flags.can_touch_runtime_system("save system time to HW clock"): timezone.save_hw_clock(ksdata.timezone) # We really only care about actions that affect filesystems, since # those are the ones that take the most time. steps = len(storage.devicetree.findActions(action_type="create", object_type="format")) + \ len(storage.devicetree.findActions(action_type="resize", object_type="format")) # Update every 10% of packages installed. We don't know how many packages # we are installing until it's too late (see realmd later on) so this is # the best we can do. steps += 11 # pre setup phase, post install steps += 2 # realmd, maybe if willRunRealmd: steps += 1 # bootloader, maybe if willInstallBootloader: steps += 1 # This should be the only thread running, wait for the others to finish if not. if threadMgr.running > 1: progress_init(steps + 1) with progress_report( _("Waiting for %s threads to finish") % (threadMgr.running - 1)): for message in ("Thread %s is running" % n for n in threadMgr.names): log.debug(message) threadMgr.wait_all() else: progress_init(steps) with progress_report(_("Setting up the installation environment")): ksdata.firstboot.setup(storage, ksdata, instClass) ksdata.addons.setup(storage, ksdata, instClass) storage.updateKSData() # this puts custom storage info into ksdata # Do partitioning. payload.preStorage() # callbacks for blivet message_clbk = lambda clbk_data: progress_message(clbk_data.msg) step_clbk = lambda clbk_data: progress_step(clbk_data.msg) entropy_wait_clbk = lambda clbk_data: wait_for_entropy( clbk_data.msg, clbk_data.min_entropy, ksdata) callbacks_reg = callbacks.create_new_callbacks_register( create_format_pre=message_clbk, create_format_post=step_clbk, resize_format_pre=message_clbk, resize_format_post=step_clbk, wait_for_entropy=entropy_wait_clbk) turnOnFilesystems(storage, mountOnly=flags.flags.dirInstall, callbacks=callbacks_reg) payload.writeStorageEarly() # Run %pre-install scripts with the filesystem mounted and no packages with progress_report(_("Running pre-installation scripts")): runPreInstallScripts(ksdata.scripts) # Do packaging. # Discover information about realms to join, # to determine additional packages if willRunRealmd: with progress_report(_("Discovering realm to join")): ksdata.realm.setup() # Check for additional packages ksdata.authconfig.setup() ksdata.firewall.setup() ksdata.network.setup() # make name resolution work for rpm scripts in chroot if flags.can_touch_runtime_system("copy /etc/resolv.conf to sysroot"): network.copyFileToPath("/etc/resolv.conf", iutil.getSysroot()) # anaconda requires storage packages in order to make sure the target # system is bootable and configurable, and some other packages in order # to finish setting up the system. packages = storage.packages + ksdata.realm.packages packages += ksdata.authconfig.packages + ksdata.firewall.packages + ksdata.network.packages if willInstallBootloader: packages += storage.bootloader.packages # don't try to install packages from the install class' ignored list and the # explicitly excluded ones (user takes the responsibility) packages = [ p for p in packages if p not in instClass.ignoredPackages and p not in ksdata.packages.excludedList ] payload.preInstall(packages=packages, groups=payload.languageGroups()) payload.install() payload.writeStorageLate() # Do bootloader. if willInstallBootloader: with progress_report(_("Installing boot loader")): writeBootLoader(storage, payload, instClass, ksdata) with progress_report(_("Performing post-installation setup tasks")): payload.postInstall() progress_complete()
def doConfiguration(storage, payload, ksdata, instClass): from pyanaconda.kickstart import runPostScripts willWriteNetwork = not flags.flags.imageInstall and not flags.flags.dirInstall willRunRealmd = ksdata.realm.discovered # configure base, create users, configure addons, initramfs, post-install step_count = 5 # network, maybe if willWriteNetwork: step_count += 1 # if a realm was discovered, # increment the counter as the # real joining step will be executed if willRunRealmd: step_count += 1 progress_init(step_count) # Now run the execute methods of ksdata that require an installed system # to be present first. with progress_report(_("Configuring installed system")): ksdata.authconfig.execute(storage, ksdata, instClass) ksdata.selinux.execute(storage, ksdata, instClass) ksdata.firstboot.execute(storage, ksdata, instClass) ksdata.services.execute(storage, ksdata, instClass) ksdata.keyboard.execute(storage, ksdata, instClass) ksdata.timezone.execute(storage, ksdata, instClass) ksdata.lang.execute(storage, ksdata, instClass) ksdata.firewall.execute(storage, ksdata, instClass) ksdata.xconfig.execute(storage, ksdata, instClass) ksdata.skipx.execute(storage, ksdata, instClass) if willWriteNetwork: with progress_report(_("Writing network configuration")): ksdata.network.execute(storage, ksdata, instClass) # Creating users and groups requires some pre-configuration. with progress_report(_("Creating users")): createLuserConf(iutil.getSysroot(), algoname=getPassAlgo(ksdata.authconfig.authconfig)) u = Users() ksdata.rootpw.execute(storage, ksdata, instClass, u) ksdata.group.execute(storage, ksdata, instClass, u) ksdata.user.execute(storage, ksdata, instClass, u) with progress_report(_("Configuring addons")): ksdata.addons.execute(storage, ksdata, instClass, u) with progress_report(_("Generating initramfs")): payload.recreateInitrds(force=True) if willRunRealmd: with progress_report(_("Joining realm: %s") % ksdata.realm.discovered): ksdata.realm.execute(storage, ksdata, instClass) with progress_report(_("Running post-installation scripts")): runPostScripts(ksdata.scripts) # setup kexec reboot if requested if flags.flags.kexec: setup_kexec() # Write the kickstart file to the installed system (or, copy the input # kickstart file over if one exists). _writeKS(ksdata) progress_complete()
def doConfiguration(storage, payload, ksdata, instClass): willWriteNetwork = not flags.flags.imageInstall and not flags.flags.dirInstall willRunRealmd = ksdata.realm.discovered # configure base, create users, configure addons, initramfs, post-install step_count = 5 # network, maybe if willWriteNetwork: step_count += 1 # if a realm was discovered, # increment the counter as the # real joining step will be executed if willRunRealmd: step_count += 1 if ksdata.snapshot and ksdata.snapshot.has_snapshot(SNAPSHOT_WHEN_POST_INSTALL): step_count += 1 progress_init(step_count) # Now run the execute methods of ksdata that require an installed system # to be present first. with progress_report(_("Configuring installed system")): ksdata.authconfig.execute(storage, ksdata, instClass) ksdata.selinux.execute(storage, ksdata, instClass) ksdata.firstboot.execute(storage, ksdata, instClass) ksdata.services.execute(storage, ksdata, instClass) ksdata.keyboard.execute(storage, ksdata, instClass) ksdata.timezone.execute(storage, ksdata, instClass) ksdata.lang.execute(storage, ksdata, instClass) ksdata.firewall.execute(storage, ksdata, instClass) ksdata.xconfig.execute(storage, ksdata, instClass) ksdata.skipx.execute(storage, ksdata, instClass) if willWriteNetwork: with progress_report(_("Writing network configuration")): ksdata.network.execute(storage, ksdata, instClass) # Creating users and groups requires some pre-configuration. with progress_report(_("Creating users")): createLuserConf(iutil.getSysroot(), algoname=getPassAlgo(ksdata.authconfig.authconfig)) u = Users() ksdata.rootpw.execute(storage, ksdata, instClass, u) ksdata.group.execute(storage, ksdata, instClass, u) ksdata.user.execute(storage, ksdata, instClass, u) ksdata.sshkey.execute(storage, ksdata, instClass, u) with progress_report(_("Configuring addons")): ksdata.addons.execute(storage, ksdata, instClass, u, payload) with progress_report(_("Generating initramfs")): payload.recreateInitrds(force=True) if willRunRealmd: with progress_report(_("Joining realm: %s") % ksdata.realm.discovered): ksdata.realm.execute(storage, ksdata, instClass) with progress_report(_("Running post-installation scripts")): runPostScripts(ksdata.scripts) # setup kexec reboot if requested if flags.flags.kexec: setup_kexec() # 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: _writeKS(ksdata) # write out the user interaction config file screen_access.sam.write_out_config_file() if ksdata.snapshot and ksdata.snapshot.has_snapshot(SNAPSHOT_WHEN_POST_INSTALL): with progress_report(N_("Creating snapshots")): ksdata.snapshot.execute(storage, ksdata, instClass) progress_complete()
def doInstall(storage, payload, ksdata): """Perform an installation. This method takes the ksdata as prepared by the UI (the first hub, in graphical mode) and applies it to the disk. The two main tasks for this are putting filesystems onto disks and installing packages onto those filesystems. """ bootloader_proxy = STORAGE.get_proxy(BOOTLOADER) bootloader_enabled = bootloader_proxy.BootloaderMode != BOOTLOADER_DISABLED can_install_bootloader = not conf.target.is_directory and bootloader_enabled installation_queue = TaskQueue("Installation queue") # connect progress reporting installation_queue.queue_started.connect( lambda x: progress_message(x.status_message)) installation_queue.task_completed.connect(lambda x: progress_step(x.name)) # This should be the only thread running, wait for the others to finish if not. if threadMgr.running > 1: # it could be that the threads finish execution before the task is executed, # but that should not cause any issues def wait_for_all_treads(): for message in ("Thread %s is running" % n for n in threadMgr.names): log.debug(message) threadMgr.wait_all() # Use a queue with a single task as only TaskQueues have the status_message # property used for setting the progress status in the UI. wait_for_threads = TaskQueue( "Wait for threads to finish", N_("Waiting for %s threads to finish") % (threadMgr.running - 1)) wait_for_threads.append( Task("Wait for all threads to finish", wait_for_all_treads)) installation_queue.append(wait_for_threads) # Save system time to HW clock. # - this used to be before waiting on threads, but I don't think that's needed if conf.system.can_set_hardware_clock: # lets just do this as a top-level task - no save_hwclock = Task("Save system time to HW clock", timezone.save_hw_clock) installation_queue.append(save_hwclock) # setup the installation environment setup_environment = TaskQueue( "Installation environment setup", N_("Setting up the installation environment")) setup_environment.append( Task("Setup addons", ksdata.addons.setup, (storage, ksdata, payload))) installation_queue.append(setup_environment) # Do partitioning. # Depending on current payload the storage might be apparently configured # either before or after package/payload installation. # So let's have two task queues - early storage & late storage. early_storage = TaskQueue("Early storage configuration", N_("Configuring storage")) # put custom storage info into ksdata early_storage.append( Task("Insert custom storage to ksdata", task=update_storage_ksdata, task_args=(storage, ksdata))) # callbacks for blivet message_clbk = lambda clbk_data: progress_message(clbk_data.msg) entropy_wait_clbk = lambda clbk_data: wait_for_entropy( clbk_data.msg, clbk_data.min_entropy, ksdata) callbacks_reg = callbacks.create_new_callbacks_register( create_format_pre=message_clbk, resize_format_pre=message_clbk, wait_for_entropy=entropy_wait_clbk) if not conf.target.is_directory: early_storage.append( Task("Activate filesystems", task=turn_on_filesystems, task_args=(storage, ), task_kwargs={"callbacks": callbacks_reg})) early_storage.append( Task("Mount filesystems", task=storage.mount_filesystems)) if payload.needs_storage_configuration and not conf.target.is_directory: early_storage.append( Task("Write early storage", task=write_storage_configuration, task_args=(storage, ))) installation_queue.append(early_storage) # Run %pre-install scripts with the filesystem mounted and no packages pre_install_scripts = TaskQueue("Pre-install scripts", N_("Running pre-installation scripts")) pre_install_scripts.append( Task("Run %pre-install scripts", runPreInstallScripts, (ksdata.scripts, ))) installation_queue.append(pre_install_scripts) # Do packaging. # Discover information about realms to join to determine the need for additional packages. realm_discover = TaskQueue("Realm discover", N_("Discovering realm to join")) realm_discover.append(Task("Discover realm to join", ksdata.realm.setup)) installation_queue.append(realm_discover) # Check for other possibly needed additional packages. pre_install = TaskQueue("Pre install tasks", N_("Running pre-installation tasks")) pre_install.append(Task("Setup authselect", ksdata.authselect.setup)) pre_install.append(Task("Setup firewall", ksdata.firewall.setup)) pre_install.append(Task("Setup network", ksdata.network.setup)) # Setup timezone and add chrony as package if timezone was set in KS # and "-chrony" wasn't in packages section and/or --nontp wasn't set. pre_install.append( Task("Setup timezone", ksdata.timezone.setup, (ksdata, ))) # make name resolution work for rpm scripts in chroot if conf.system.provides_resolver_config: # we use a custom Task subclass as the sysroot path has to be resolved # only when the task is actually started, not at task creation time pre_install.append(WriteResolvConfTask("Copy resolv.conf to sysroot")) def run_pre_install(): """This means to gather what additional packages (if any) are needed & executing payload.pre_install().""" # anaconda requires storage packages in order to make sure the target # system is bootable and configurable, and some other packages in order # to finish setting up the system. payload.requirements.add_packages(storage.packages, reason="storage") payload.requirements.add_packages(ksdata.realm.packages, reason="realm") payload.requirements.add_packages(ksdata.authselect.packages, reason="authselect") payload.requirements.add_packages(ksdata.firewall.packages, reason="firewall") payload.requirements.add_packages(ksdata.network.packages, reason="network") payload.requirements.add_packages(ksdata.timezone.packages, reason="ntp", strong=False) if can_install_bootloader: payload.requirements.add_packages(storage.bootloader.packages, reason="bootloader") payload.requirements.add_groups(payload.language_groups(), reason="language groups") payload.requirements.add_packages(payload.langpacks(), reason="langpacks", strong=False) payload.pre_install() pre_install.append( Task("Find additional packages & run pre_install()", run_pre_install)) installation_queue.append(pre_install) payload_install = TaskQueue("Payload installation", N_("Installing.")) payload_install.append(Task("Install the payload", payload.install)) installation_queue.append(payload_install) # for some payloads storage is configured after the payload is installed if not payload.needs_storage_configuration: late_storage = TaskQueue("Late storage configuration", N_("Configuring storage")) late_storage.append( Task("Prepare mount targets", task=payload.prepare_mount_targets, task_args=(storage, ))) if not conf.target.is_directory: late_storage.append( Task("Write late storage", task=write_storage_configuration, task_args=(storage, ))) installation_queue.append(late_storage) # Do bootloader. if can_install_bootloader: bootloader_install = TaskQueue("Bootloader installation", N_("Installing boot loader")) bootloader_install.append( Task("Install bootloader", write_boot_loader, (storage, payload))) installation_queue.append(bootloader_install) post_install = TaskQueue("Post-installation setup tasks", (N_("Performing post-installation setup tasks"))) post_install.append( Task("Run post-installation setup tasks", payload.post_install)) installation_queue.append(post_install) # Create snapshot snapshot_proxy = STORAGE.get_proxy(SNAPSHOT) if snapshot_proxy.IsRequested(SNAPSHOT_WHEN_POST_INSTALL): snapshot_creation = TaskQueue("Creating post installation snapshots", N_("Creating snapshots")) snapshot_requests = ksdata.snapshot.get_requests( SNAPSHOT_WHEN_POST_INSTALL) snapshot_task = SnapshotCreateTask(storage, snapshot_requests, SNAPSHOT_WHEN_POST_INSTALL) snapshot_creation.append( Task("Create post-install snapshots", snapshot_task.run)) installation_queue.append(snapshot_creation) # notify progress tracking about the number of steps progress_init(installation_queue.task_count) # log contents of the main task queue log.info(installation_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(installation_queue.queue_count) task_started_counter = util.item_counter(installation_queue.task_count) task_completed_counter = util.item_counter(installation_queue.task_count) installation_queue.queue_started.connect(lambda x: log.info( "Queue started: %s (%s)", x.name, next(queue_counter))) installation_queue.task_started.connect(lambda x: log.info( "Task started: %s (%s)", x.name, next(task_started_counter))) installation_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 installation_queue.start() # done progress_complete()
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 doInstall(storage, payload, ksdata, instClass): """Perform an installation. This method takes the ksdata as prepared by the UI (the first hub, in graphical mode) and applies it to the disk. The two main tasks for this are putting filesystems onto disks and installing packages onto those filesystems. """ willRunRealmd = ksdata.realm.join_realm willInstallBootloader = not flags.flags.dirInstall and (not ksdata.bootloader.disabled and ksdata.bootloader != "none") # First save system time to HW clock. if flags.can_touch_runtime_system("save system time to HW clock"): timezone.save_hw_clock(ksdata.timezone) # We really only care about actions that affect filesystems, since # those are the ones that take the most time. steps = len(storage.devicetree.findActions(action_type="create", object_type="format")) + \ len(storage.devicetree.findActions(action_type="resize", object_type="format")) # Update every 10% of packages installed. We don't know how many packages # we are installing until it's too late (see realmd later on) so this is # the best we can do. steps += 11 # pre setup phase, post install steps += 2 # realmd, maybe if willRunRealmd: steps += 1 # bootloader, maybe if willInstallBootloader: steps += 1 # This should be the only thread running, wait for the others to finish if not. if threadMgr.running > 1: progress_init(steps+1) with progress_report(N_("Waiting for %s threads to finish") % (threadMgr.running-1)): for message in ("Thread %s is running" % n for n in threadMgr.names): log.debug(message) threadMgr.wait_all() else: progress_init(steps) with progress_report(N_("Setting up the installation environment")): ksdata.firstboot.setup(storage, ksdata, instClass) ksdata.addons.setup(storage, ksdata, instClass) storage.updateKSData() # this puts custom storage info into ksdata # Do partitioning. payload.preStorage() # callbacks for blivet message_clbk = lambda clbk_data: progress_message(clbk_data.msg) step_clbk = lambda clbk_data: progress_step(clbk_data.msg) entropy_wait_clbk = lambda clbk_data: wait_for_entropy(clbk_data.msg, clbk_data.min_entropy, ksdata) callbacks_reg = callbacks.create_new_callbacks_register(create_format_pre=message_clbk, create_format_post=step_clbk, resize_format_pre=message_clbk, resize_format_post=step_clbk, wait_for_entropy=entropy_wait_clbk) turnOnFilesystems(storage, mountOnly=flags.flags.dirInstall, callbacks=callbacks_reg) payload.writeStorageEarly() # Run %pre-install scripts with the filesystem mounted and no packages with progress_report(N_("Running pre-installation scripts")): runPreInstallScripts(ksdata.scripts) # Do packaging. # Discover information about realms to join, # to determine additional packages if willRunRealmd: with progress_report(N_("Discovering realm to join")): ksdata.realm.setup() # Check for additional packages ksdata.authconfig.setup() ksdata.firewall.setup() ksdata.network.setup() # Setup timezone and add chrony as package if timezone was set in KS # and "-chrony" wasn't in packages section and/or --nontp wasn't set. ksdata.timezone.setup(ksdata) # make name resolution work for rpm scripts in chroot if flags.can_touch_runtime_system("copy /etc/resolv.conf to sysroot"): network.copyFileToPath("/etc/resolv.conf", iutil.getSysroot()) # anaconda requires storage packages in order to make sure the target # system is bootable and configurable, and some other packages in order # to finish setting up the system. packages = storage.packages + ksdata.realm.packages packages += ksdata.authconfig.packages + ksdata.firewall.packages + ksdata.network.packages if willInstallBootloader: packages += storage.bootloader.packages # don't try to install packages from the install class' ignored list and the # explicitly excluded ones (user takes the responsibility) packages = [p for p in packages if p not in instClass.ignoredPackages and p not in ksdata.packages.excludedList] payload.preInstall(packages=packages, groups=payload.languageGroups()) payload.install() payload.writeStorageLate() # Do bootloader. if willInstallBootloader: with progress_report(N_("Installing boot loader")): writeBootLoader(storage, payload, instClass, ksdata) with progress_report(N_("Performing post-installation setup tasks")): payload.postInstall() progress_complete()
def doConfiguration(storage, payload, ksdata, instClass): willWriteNetwork = not flags.flags.imageInstall and not flags.flags.dirInstall willRunRealmd = ksdata.realm.discovered # configure base, create users, configure addons, initramfs, post-install step_count = 5 # network, maybe if willWriteNetwork: step_count += 1 # if a realm was discovered, # increment the counter as the # real joining step will be executed if willRunRealmd: step_count += 1 progress_init(step_count) # Now run the execute methods of ksdata that require an installed system # to be present first. with progress_report(N_("Configuring installed system")): ksdata.authconfig.execute(storage, ksdata, instClass) ksdata.selinux.execute(storage, ksdata, instClass) ksdata.firstboot.execute(storage, ksdata, instClass) ksdata.services.execute(storage, ksdata, instClass) ksdata.keyboard.execute(storage, ksdata, instClass) ksdata.timezone.execute(storage, ksdata, instClass) ksdata.lang.execute(storage, ksdata, instClass) ksdata.firewall.execute(storage, ksdata, instClass) ksdata.xconfig.execute(storage, ksdata, instClass) ksdata.skipx.execute(storage, ksdata, instClass) if willWriteNetwork: with progress_report(N_("Writing network configuration")): ksdata.network.execute(storage, ksdata, instClass) # Creating users and groups requires some pre-configuration. with progress_report(N_("Creating users")): u = Users() ksdata.rootpw.execute(storage, ksdata, instClass, u) ksdata.group.execute(storage, ksdata, instClass, u) ksdata.user.execute(storage, ksdata, instClass, u) ksdata.sshkey.execute(storage, ksdata, instClass, u) with progress_report(N_("Configuring addons")): ksdata.addons.execute(storage, ksdata, instClass, u, payload) with progress_report(N_("Generating initramfs")): payload.recreateInitrds() # 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) if flags.flags.livecdInstall and boot_on_btrfs \ and (not ksdata.bootloader.disabled and ksdata.bootloader != "none"): writeBootLoader(storage, payload, instClass, ksdata) if willRunRealmd: with progress_report( N_("Joining realm: %s") % ksdata.realm.discovered): ksdata.realm.execute(storage, ksdata, instClass) with progress_report(N_("Running post-installation scripts")): runPostScripts(ksdata.scripts) # setup kexec reboot if requested if flags.flags.kexec: setup_kexec() # 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: _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 inadvertedly hidden when the actual installation # startes from the generate image or directory contents. if flags.flags.imageInstall: log.info( "Not writing out user interaction config file due to image install mode." ) elif flags.flags.dirInstall: log.info( "Not writing out user interaction config file due to directory install mode." ) else: screen_access.sam.write_out_config_file() progress_complete()
def doInstall(storage, payload, ksdata, instClass): """Perform an installation. This method takes the ksdata as prepared by the UI (the first hub, in graphical mode) and applies it to the disk. The two main tasks for this are putting filesystems onto disks and installing packages onto those filesystems. """ willInstallBootloader = not flags.flags.dirInstall and (not ksdata.bootloader.disabled and ksdata.bootloader != "none") installation_queue = TaskQueue("Installation queue") # connect progress reporting installation_queue.queue_started.connect(lambda x: progress_message(x.status_message)) installation_queue.queue_completed.connect(lambda x: progress_step("%s -- DONE" % x.status_message)) # This should be the only thread running, wait for the others to finish if not. if threadMgr.running > 1: # it could be that the threads finish execution before the task is executed, # but that should not cause any issues def wait_for_all_treads(): for message in ("Thread %s is running" % n for n in threadMgr.names): log.debug(message) threadMgr.wait_all() # Use a queue with a single task as only TaskQueues have the status_message # property used for setting the progress status in the UI. wait_for_threads = TaskQueue("Wait for threads to finish", N_("Waiting for %s threads to finish") % (threadMgr.running - 1)) wait_for_threads.append(Task("Wait for all threads to finish", wait_for_all_treads)) installation_queue.append(wait_for_threads) # Save system time to HW clock. # - this used to be before waiting on threads, but I don't think that's needed if flags.can_touch_runtime_system("save system time to HW clock"): # lets just do this as a top-level task - no save_hwclock = Task("Save system time to HW clock", timezone.save_hw_clock, (ksdata.timezone,)) installation_queue.append(save_hwclock) # setup the installation environment setup_environment = TaskQueue("Installation environment setup", N_("Setting up the installation environment")) setup_environment.append(Task("Setup firstboot", ksdata.firstboot.setup, (ksdata, instClass))) setup_environment.append(Task("Setup addons", ksdata.addons.setup, (storage, ksdata, instClass, payload))) installation_queue.append(setup_environment) # Do partitioning. # Depending on current payload the storage might be apparently configured # either before or after package/payload installation. # So let's have two task queues - early storage & late storage. early_storage = TaskQueue("Early storage configuration", N_("Configuring storage")) # put custom storage info into ksdata early_storage.append(Task("Insert custom storage to ksdata", storage.update_ksdata)) # pre-storage tasks # - Is this actually needed ? It does not appear to do anything right now. early_storage.append(Task("Run pre-storage tasks", payload.preStorage)) # callbacks for blivet message_clbk = lambda clbk_data: progress_message(clbk_data.msg) step_clbk = lambda clbk_data: progress_step(clbk_data.msg) entropy_wait_clbk = lambda clbk_data: wait_for_entropy(clbk_data.msg, clbk_data.min_entropy, ksdata) callbacks_reg = callbacks.create_new_callbacks_register(create_format_pre=message_clbk, create_format_post=step_clbk, resize_format_pre=message_clbk, resize_format_post=step_clbk, wait_for_entropy=entropy_wait_clbk) early_storage.append(Task("Activate filesystems", task=turn_on_filesystems, task_args=(storage,), task_kwargs={"mount_only": flags.flags.dirInstall, "callbacks": callbacks_reg})) early_storage.append(Task("Write early storage", payload.writeStorageEarly)) installation_queue.append(early_storage) # Run %pre-install scripts with the filesystem mounted and no packages pre_install_scripts = TaskQueue("Pre-install scripts", N_("Running pre-installation scripts")) pre_install_scripts.append(Task("Run %pre-install scripts", runPreInstallScripts, (ksdata.scripts,))) installation_queue.append(pre_install_scripts) # Do packaging. # Discover information about realms to join to determine the need for additional packages. if ksdata.realm.join_realm: realm_discover = TaskQueue("Realm discover", N_("Discovering realm to join")) realm_discover.append(Task("Discover realm to join", ksdata.realm.setup)) installation_queue.append(realm_discover) # Check for other possibly needed additional packages. pre_install = TaskQueue("Pre install tasks", N_("Running pre-installation tasks")) pre_install.append(Task("Setup authconfig", ksdata.authconfig.setup)) pre_install.append(Task("Setup firewall", ksdata.firewall.setup)) pre_install.append(Task("Setup network", ksdata.network.setup)) # Setup timezone and add chrony as package if timezone was set in KS # and "-chrony" wasn't in packages section and/or --nontp wasn't set. pre_install.append(Task("Setup timezone", ksdata.timezone.setup, (ksdata,))) # make name resolution work for rpm scripts in chroot if flags.can_touch_runtime_system("copy /etc/resolv.conf to sysroot"): # we use a custom Task subclass as the sysroot path has to be resolved # only when the task is actually started, not at task creation time pre_install.append(WriteResolvConfTask("Copy /resolv.conf to sysroot")) def run_pre_install(): """This means to gather what additional packages (if any) are needed & executing payload.preInstall().""" # anaconda requires storage packages in order to make sure the target # system is bootable and configurable, and some other packages in order # to finish setting up the system. packages = storage.packages + ksdata.realm.packages packages += ksdata.authconfig.packages + ksdata.firewall.packages + ksdata.network.packages if willInstallBootloader: packages += storage.bootloader.packages # don't try to install packages from the install class' ignored list and the # explicitly excluded ones (user takes the responsibility) packages = [p for p in packages if p not in instClass.ignoredPackages and p not in ksdata.packages.excludedList] payload.preInstall(packages=packages, groups=payload.languageGroups()) pre_install.append(Task("Find additional packages & run preInstall()", run_pre_install)) installation_queue.append(pre_install) payload_install = TaskQueue("Payload installation", N_("Installing.")) payload_install.append(Task("Install the payload", payload.install)) installation_queue.append(payload_install) # for some payloads storage is configured after the payload is installed late_storage = TaskQueue("Late storage configuration", N_("Configuring storage")) late_storage.append(Task("Write late storage", payload.writeStorageLate)) installation_queue.append(late_storage) # Do bootloader. if willInstallBootloader: bootloader_install = TaskQueue("Bootloader installation", N_("Installing boot loader")) bootloader_install.append(Task("Install bootloader", writeBootLoader, (storage, payload, instClass, ksdata))) installation_queue.append(bootloader_install) post_install = TaskQueue("Post-installation setup tasks", (N_("Performing post-installation setup tasks"))) post_install.append(Task("Run post-installation setup tasks", payload.postInstall)) installation_queue.append(post_install) # notify progress tracking about the number of steps progress_init(len(installation_queue)) # log contents of the main task queue log.info(installation_queue.summary) # log tasks and queues when they are started # - note that we are using generators to add the counter queue_counter = iutil.item_counter(installation_queue.queue_count) task_started_counter = iutil.item_counter(installation_queue.task_count) task_completed_counter = iutil.item_counter(installation_queue.task_count) installation_queue.queue_started.connect(lambda x: log.info("Queue started: %s (%s)", x.name, next(queue_counter))) installation_queue.task_started.connect(lambda x: log.info("Task started: %s (%s)", x.name, next(task_started_counter))) installation_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 installation_queue.start() # done progress_complete()
def doConfiguration(storage, payload, ksdata, instClass): willWriteNetwork = not flags.flags.imageInstall and not flags.flags.dirInstall willRunRealmd = ksdata.realm.discovered # configure base, create users, configure addons, initramfs, post-install step_count = 5 # network, maybe if willWriteNetwork: step_count += 1 # if a realm was discovered, # increment the counter as the # real joining step will be executed if willRunRealmd: step_count += 1 progress_init(step_count) # Now run the execute methods of ksdata that require an installed system # to be present first. with progress_report(N_("Configuring installed system")): ksdata.authconfig.execute(storage, ksdata, instClass) ksdata.selinux.execute(storage, ksdata, instClass) ksdata.firstboot.execute(storage, ksdata, instClass) ksdata.services.execute(storage, ksdata, instClass) ksdata.keyboard.execute(storage, ksdata, instClass) ksdata.timezone.execute(storage, ksdata, instClass) ksdata.lang.execute(storage, ksdata, instClass) ksdata.firewall.execute(storage, ksdata, instClass) ksdata.xconfig.execute(storage, ksdata, instClass) ksdata.skipx.execute(storage, ksdata, instClass) if willWriteNetwork: with progress_report(N_("Writing network configuration")): ksdata.network.execute(storage, ksdata, instClass) # Creating users and groups requires some pre-configuration. with progress_report(N_("Creating users")): u = Users() ksdata.rootpw.execute(storage, ksdata, instClass, u) ksdata.group.execute(storage, ksdata, instClass, u) ksdata.user.execute(storage, ksdata, instClass, u) ksdata.sshkey.execute(storage, ksdata, instClass, u) with progress_report(N_("Configuring addons")): ksdata.addons.execute(storage, ksdata, instClass, u, payload) with progress_report(N_("Generating initramfs")): payload.recreateInitrds() # 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) if flags.flags.livecdInstall and boot_on_btrfs \ and (not ksdata.bootloader.disabled and ksdata.bootloader != "none"): writeBootLoader(storage, payload, instClass, ksdata) if willRunRealmd: with progress_report(N_("Joining realm: %s") % ksdata.realm.discovered): ksdata.realm.execute(storage, ksdata, instClass) with progress_report(N_("Running post-installation scripts")): runPostScripts(ksdata.scripts) # setup kexec reboot if requested if flags.flags.kexec: setup_kexec() # 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: _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 inadvertedly hidden when the actual installation # startes from the generate image or directory contents. if flags.flags.imageInstall: log.info("Not writing out user interaction config file due to image install mode.") elif flags.flags.dirInstall: log.info("Not writing out user interaction config file due to directory install mode.") else: screen_access.sam.write_out_config_file() progress_complete()
def doConfiguration(storage, payload, ksdata, instClass): from pyanaconda.kickstart import runPostScripts willWriteNetwork = not flags.flags.imageInstall and not flags.flags.dirInstall willRunRealmd = ksdata.realm.discovered # configure base, create users, configure addons, initramfs, post-install step_count = 5 # network, maybe if willWriteNetwork: step_count += 1 # if a realm was discovered, # increment the counter as the # real joining step will be executed if willRunRealmd: step_count += 1 progress_init(step_count) # Now run the execute methods of ksdata that require an installed system # to be present first. with progress_report(_("Configuring installed system")): ksdata.authconfig.execute(storage, ksdata, instClass) ksdata.selinux.execute(storage, ksdata, instClass) ksdata.firstboot.execute(storage, ksdata, instClass) ksdata.services.execute(storage, ksdata, instClass) ksdata.keyboard.execute(storage, ksdata, instClass) ksdata.timezone.execute(storage, ksdata, instClass) ksdata.lang.execute(storage, ksdata, instClass) ksdata.firewall.execute(storage, ksdata, instClass) ksdata.xconfig.execute(storage, ksdata, instClass) ksdata.skipx.execute(storage, ksdata, instClass) if willWriteNetwork: with progress_report(_("Writing network configuration")): ksdata.network.execute(storage, ksdata, instClass) # Creating users and groups requires some pre-configuration. with progress_report(_("Creating users")): createLuserConf(iutil.getSysroot(), algoname=getPassAlgo(ksdata.authconfig.authconfig)) u = Users() ksdata.rootpw.execute(storage, ksdata, instClass, u) ksdata.group.execute(storage, ksdata, instClass, u) ksdata.user.execute(storage, ksdata, instClass, u) with progress_report(_("Configuring addons")): ksdata.addons.execute(storage, ksdata, instClass, u) with progress_report(_("Generating initramfs")): payload.recreateInitrds(force=True) if willRunRealmd: with progress_report(_("Joining realm: %s") % ksdata.realm.discovered): ksdata.realm.execute(storage, ksdata, instClass) with progress_report(_("Running post-installation scripts")): runPostScripts(ksdata.scripts) # Write the kickstart file to the installed system (or, copy the input # kickstart file over if one exists). _writeKS(ksdata) progress_complete()
def doInstall(storage, payload, ksdata, instClass): """Perform an installation. This method takes the ksdata as prepared by the UI (the first hub, in graphical mode) and applies it to the disk. The two main tasks for this are putting filesystems onto disks and installing packages onto those filesystems. """ willRunRealmd = ksdata.realm.join_realm willInstallBootloader = not flags.flags.dirInstall and not ksdata.bootloader.disabled # First save system time to HW clock. if flags.can_touch_runtime_system("save system time to HW clock"): timezone.save_hw_clock(ksdata.timezone) # We really only care about actions that affect filesystems, since # those are the ones that take the most time. steps = len(storage.devicetree.findActions(action_type="create", object_type="format")) + \ len(storage.devicetree.findActions(action_type="resize", object_type="format")) # Update every 10% of packages installed. We don't know how many packages # we are installing until it's too late (see realmd later on) so this is # the best we can do. steps += 10 # pre setup phase, post install steps += 2 # realmd, maybe if willRunRealmd: steps += 1 # bootloader, maybe if willInstallBootloader: steps += 1 # This should be the only thread running, wait for the others to finish if not. if threadMgr.running > 1: progress_init(steps + 1) with progress_report( _("Waiting for %s threads to finish") % (threadMgr.running - 1)): map(log.debug, ("Thread %s is running" % n for n in threadMgr.names)) threadMgr.wait_all() else: progress_init(steps) with progress_report(_("Setting up the installation environment")): ksdata.firstboot.setup(storage, ksdata, instClass) ksdata.addons.setup(storage, ksdata, instClass) storage.updateKSData() # this puts custom storage info into ksdata # Do partitioning. payload.preStorage() # callbacks for blivet message_clbk = lambda clbk_data: progress_message(clbk_data.msg) step_clbk = lambda clbk_data: progress_step(clbk_data.msg) entropy_wait_clbk = lambda clbk_data: wait_for_entropy( clbk_data.msg, clbk_data.min_entropy, ksdata) callbacks_reg = callbacks.create_new_callbacks_register( create_format_pre=message_clbk, create_format_post=step_clbk, resize_format_pre=message_clbk, resize_format_post=step_clbk, wait_for_entropy=entropy_wait_clbk) turnOnFilesystems(storage, mountOnly=flags.flags.dirInstall, callbacks=callbacks_reg) write_storage_late = (flags.flags.livecdInstall or ksdata.ostreesetup.seen or ksdata.method.method == "liveimg") if not write_storage_late and not flags.flags.dirInstall: storage.write() # STACKIQ file = open('/proc/cmdline', 'r') args = file.readline().split() file.close() if 'boss' in args: import subprocess # # if we are a boss, then download the selected rolls # log.debug('STACKI: Downloading pallets: start') s = subprocess.Popen('/opt/stack/bin/boss_download_pallets.py') s.wait() log.debug('STACKI: Downloading pallets: complete') payload.reset() # # # for repo in payload._yum.repos.repos.values(): log.debug('STACKI: repo.id (%s)' % repo.id) if repo.id != 'stacki': log.debug('STACKI: disabling repo repo.id (%s)' % repo.id) payload.disableRepo(repo.id) else: # # need to setup a symbolic link in order to store all the packages # downloaded by lighttpd # import os cmd = 'rm -rf /install ; ' cmd += 'mkdir -p /mnt/sysimage/install ; ' cmd += 'ln -s /mnt/sysimage/install /install' os.system(cmd) # STACKIQ # Do packaging. # Discover information about realms to join, # to determine additional packages if willRunRealmd: with progress_report(_("Discovering realm to join")): ksdata.realm.setup() # Check for additional packages ksdata.authconfig.setup() ksdata.firewall.setup() # make name resolution work for rpm scripts in chroot if flags.can_touch_runtime_system("copy /etc/resolv.conf to sysroot"): network.copyFileToPath("/etc/resolv.conf", iutil.getSysroot()) # anaconda requires storage packages in order to make sure the target # system is bootable and configurable, and some other packages in order # to finish setting up the system. packages = storage.packages + ksdata.realm.packages packages += ksdata.authconfig.packages + ksdata.firewall.packages if not ksdata.bootloader.disabled: packages += storage.bootloader.packages if network.is_using_team_device: packages.append("teamd") # don't try to install packages from the install class' ignored list and the # explicitly excluded ones (user takes the responsibility) packages = [ p for p in packages if p not in instClass.ignoredPackages and p not in ksdata.packages.excludedList ] payload.preInstall(packages=packages, groups=payload.languageGroups()) payload.install() if write_storage_late and not flags.flags.dirInstall: if iutil.getSysroot() != iutil.getTargetPhysicalRoot(): blivet.setSysroot(iutil.getTargetPhysicalRoot(), iutil.getSysroot()) storage.write() # Now that we have the FS layout in the target, umount # things that were in the legacy sysroot, and put them in # the target root, except for the physical /. First, # unmount all target filesystems. storage.umountFilesystems() # Explicitly mount the root on the physical sysroot rootmnt = storage.mountpoints.get('/') rootmnt.setup() rootmnt.format.setup(options=rootmnt.format.options, chroot=iutil.getTargetPhysicalRoot()) payload.prepareMountTargets(storage) # Everything else goes in the target root, including /boot # since the bootloader code will expect to find /boot # inside the chroot. storage.mountFilesystems(skipRoot=True) else: storage.write() # Do bootloader. if willInstallBootloader: with progress_report(_("Installing boot loader")): writeBootLoader(storage, payload, instClass, ksdata) with progress_report(_("Performing post-installation setup tasks")): payload.postInstall() progress_complete()
def doInstall(storage, payload, ksdata, instClass): """Perform an installation. This method takes the ksdata as prepared by the UI (the first hub, in graphical mode) and applies it to the disk. The two main tasks for this are putting filesystems onto disks and installing packages onto those filesystems. """ bootloader_proxy = STORAGE.get_proxy(BOOTLOADER) bootloader_enabled = bootloader_proxy.BootloaderMode != BOOTLOADER_DISABLED can_install_bootloader = not conf.target.is_directory and bootloader_enabled installation_queue = TaskQueue("Installation queue") # connect progress reporting installation_queue.queue_started.connect(lambda x: progress_message(x.status_message)) installation_queue.task_completed.connect(lambda x: progress_step(x.name)) # This should be the only thread running, wait for the others to finish if not. if threadMgr.running > 1: # it could be that the threads finish execution before the task is executed, # but that should not cause any issues def wait_for_all_treads(): for message in ("Thread %s is running" % n for n in threadMgr.names): log.debug(message) threadMgr.wait_all() # Use a queue with a single task as only TaskQueues have the status_message # property used for setting the progress status in the UI. wait_for_threads = TaskQueue("Wait for threads to finish", N_("Waiting for %s threads to finish") % (threadMgr.running - 1)) wait_for_threads.append(Task("Wait for all threads to finish", wait_for_all_treads)) installation_queue.append(wait_for_threads) # Save system time to HW clock. # - this used to be before waiting on threads, but I don't think that's needed if conf.system.can_set_hardware_clock: # lets just do this as a top-level task - no save_hwclock = Task("Save system time to HW clock", timezone.save_hw_clock) installation_queue.append(save_hwclock) # setup the installation environment setup_environment = TaskQueue("Installation environment setup", N_("Setting up the installation environment")) setup_environment.append(Task("Setup addons", ksdata.addons.setup, (storage, ksdata, instClass, payload))) installation_queue.append(setup_environment) # Do partitioning. # Depending on current payload the storage might be apparently configured # either before or after package/payload installation. # So let's have two task queues - early storage & late storage. early_storage = TaskQueue("Early storage configuration", N_("Configuring storage")) # put custom storage info into ksdata, but not if just assigning mount points manual_part_proxy = STORAGE.get_proxy(MANUAL_PARTITIONING) if not manual_part_proxy.Enabled: early_storage.append(Task("Insert custom storage to ksdata", storage.update_ksdata)) # pre-storage tasks # - Is this actually needed ? It does not appear to do anything right now. early_storage.append(Task("Run pre-storage tasks", payload.preStorage)) # callbacks for blivet message_clbk = lambda clbk_data: progress_message(clbk_data.msg) entropy_wait_clbk = lambda clbk_data: wait_for_entropy(clbk_data.msg, clbk_data.min_entropy, ksdata) callbacks_reg = callbacks.create_new_callbacks_register(create_format_pre=message_clbk, resize_format_pre=message_clbk, wait_for_entropy=entropy_wait_clbk) if conf.target.is_directory: early_storage.append(Task("Mount filesystems", task=storage.mount_filesystems)) else: early_storage.append(Task("Activate filesystems", task=turn_on_filesystems, task_args=(storage,), task_kwargs={"callbacks": callbacks_reg})) early_storage.append(Task("Write early storage", payload.writeStorageEarly)) installation_queue.append(early_storage) # Run %pre-install scripts with the filesystem mounted and no packages pre_install_scripts = TaskQueue("Pre-install scripts", N_("Running pre-installation scripts")) pre_install_scripts.append(Task("Run %pre-install scripts", runPreInstallScripts, (ksdata.scripts,))) installation_queue.append(pre_install_scripts) # Do packaging. # Discover information about realms to join to determine the need for additional packages. realm_discover = TaskQueue("Realm discover", N_("Discovering realm to join")) realm_discover.append(Task("Discover realm to join", ksdata.realm.setup)) installation_queue.append(realm_discover) # Check for other possibly needed additional packages. pre_install = TaskQueue("Pre install tasks", N_("Running pre-installation tasks")) pre_install.append(Task("Setup authselect", ksdata.authselect.setup)) pre_install.append(Task("Setup firewall", ksdata.firewall.setup)) pre_install.append(Task("Setup network", ksdata.network.setup)) # Setup timezone and add chrony as package if timezone was set in KS # and "-chrony" wasn't in packages section and/or --nontp wasn't set. pre_install.append(Task("Setup timezone", ksdata.timezone.setup, (ksdata,))) # make name resolution work for rpm scripts in chroot if conf.system.provides_resolver_config: # we use a custom Task subclass as the sysroot path has to be resolved # only when the task is actually started, not at task creation time pre_install.append(WriteResolvConfTask("Copy /resolv.conf to sysroot")) def run_pre_install(): """This means to gather what additional packages (if any) are needed & executing payload.preInstall().""" # anaconda requires storage packages in order to make sure the target # system is bootable and configurable, and some other packages in order # to finish setting up the system. payload.requirements.add_packages(storage.packages, reason="storage") payload.requirements.add_packages(ksdata.realm.packages, reason="realm") payload.requirements.add_packages(ksdata.authselect.packages, reason="authselect") payload.requirements.add_packages(ksdata.firewall.packages, reason="firewall") payload.requirements.add_packages(ksdata.network.packages, reason="network") payload.requirements.add_packages(ksdata.timezone.packages, reason="ntp", strong=False) if can_install_bootloader: payload.requirements.add_packages(storage.bootloader.packages, reason="bootloader") payload.requirements.add_groups(payload.languageGroups(), reason="language groups") payload.requirements.add_packages(payload.langpacks(), reason="langpacks", strong=False) payload.preInstall() pre_install.append(Task("Find additional packages & run preInstall()", run_pre_install)) installation_queue.append(pre_install) payload_install = TaskQueue("Payload installation", N_("Installing.")) payload_install.append(Task("Install the payload", payload.install)) installation_queue.append(payload_install) # for some payloads storage is configured after the payload is installed late_storage = TaskQueue("Late storage configuration", N_("Configuring storage")) late_storage.append(Task("Write late storage", payload.writeStorageLate)) installation_queue.append(late_storage) # Do bootloader. if can_install_bootloader: bootloader_install = TaskQueue("Bootloader installation", N_("Installing boot loader")) bootloader_install.append(Task("Install bootloader", writeBootLoader, (storage, payload, instClass, ksdata))) installation_queue.append(bootloader_install) post_install = TaskQueue("Post-installation setup tasks", (N_("Performing post-installation setup tasks"))) post_install.append(Task("Run post-installation setup tasks", payload.postInstall)) installation_queue.append(post_install) # Create snapshot if ksdata.snapshot and ksdata.snapshot.has_snapshot(SNAPSHOT_WHEN_POST_INSTALL): snapshot_creation = TaskQueue("Creating post installation snapshots", N_("Creating snapshots")) snapshot_creation.append(Task("Create post-install snapshots", ksdata.snapshot.execute, (storage, ksdata, instClass))) installation_queue.append(snapshot_creation) # notify progress tracking about the number of steps progress_init(installation_queue.task_count) # log contents of the main task queue log.info(installation_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(installation_queue.queue_count) task_started_counter = util.item_counter(installation_queue.task_count) task_completed_counter = util.item_counter(installation_queue.task_count) installation_queue.queue_started.connect(lambda x: log.info("Queue started: %s (%s)", x.name, next(queue_counter))) installation_queue.task_started.connect(lambda x: log.info("Task started: %s (%s)", x.name, next(task_started_counter))) installation_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 installation_queue.start() # done progress_complete()
def doConfiguration(storage, payload, ksdata, instClass): """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, (storage, ksdata, instClass))) os_config.append(Task("Configure SELinux", ksdata.selinux.execute, (storage, ksdata, instClass))) os_config.append(Task("Configure first boot tasks", ksdata.firstboot.execute, (storage, ksdata, instClass))) os_config.append(Task("Configure services", ksdata.services.execute, (storage, ksdata, instClass))) os_config.append(Task("Configure keyboard", ksdata.keyboard.execute, (storage, ksdata, instClass))) os_config.append(Task("Configure timezone", ksdata.timezone.execute, (storage, ksdata, instClass))) os_config.append(Task("Configure language", ksdata.lang.execute, (storage, ksdata, instClass))) os_config.append(Task("Configure firewall", ksdata.firewall.execute, (storage, ksdata, instClass))) os_config.append(Task("Configure X", ksdata.xconfig.execute, (storage, ksdata, instClass))) 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, (storage, payload, ksdata, instClass))) 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, instClass, u))) user_config.append(Task("Configure user groups", ksdata.group.execute, (storage, ksdata, instClass, u))) user_config.append(Task("Configure user", ksdata.user.execute, (storage, ksdata, instClass, u))) user_config.append(Task("Configure SSH key", ksdata.sshkey.execute, (storage, ksdata, instClass, 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, instClass, u, payload))) configuration_queue.append(addon_config) # Initramfs generation generate_initramfs = TaskQueue("Initramfs generation", N_("Generating initramfs")) generate_initramfs.append(Task("Generate initramfs", payload.recreateInitrds)) # 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", writeBootLoader, (storage, payload, instClass, ksdata))) 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, (storage, ksdata, instClass))) 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 doInstall(storage, payload, ksdata, instClass): """Perform an installation. This method takes the ksdata as prepared by the UI (the first hub, in graphical mode) and applies it to the disk. The two main tasks for this are putting filesystems onto disks and installing packages onto those filesystems. """ willInstallBootloader = not flags.flags.dirInstall and ( not ksdata.bootloader.disabled and ksdata.bootloader != "none") installation_queue = TaskQueue("Installation queue") # connect progress reporting installation_queue.queue_started.connect( lambda x: progress_message(x.status_message)) installation_queue.queue_completed.connect( lambda x: progress_step("%s -- DONE" % x.status_message)) # This should be the only thread running, wait for the others to finish if not. if threadMgr.running > 1: # it could be that the threads finish execution before the task is executed, # but that should not cause any issues def wait_for_all_treads(): for message in ("Thread %s is running" % n for n in threadMgr.names): log.debug(message) threadMgr.wait_all() # Use a queue with a single task as only TaskQueues have the status_message # property used for setting the progress status in the UI. wait_for_threads = TaskQueue( "Wait for threads to finish", N_("Waiting for %s threads to finish") % (threadMgr.running - 1)) wait_for_threads.append( Task("Wait for all threads to finish", wait_for_all_treads)) installation_queue.append(wait_for_threads) # Save system time to HW clock. # - this used to be before waiting on threads, but I don't think that's needed if flags.can_touch_runtime_system("save system time to HW clock"): # lets just do this as a top-level task - no save_hwclock = Task("Save system time to HW clock", timezone.save_hw_clock, (ksdata.timezone, )) installation_queue.append(save_hwclock) # setup the installation environment setup_environment = TaskQueue( "Installation environment setup", N_("Setting up the installation environment")) setup_environment.append( Task("Setup firstboot", ksdata.firstboot.setup, (ksdata, instClass))) setup_environment.append( Task("Setup addons", ksdata.addons.setup, (storage, ksdata, instClass, payload))) installation_queue.append(setup_environment) # Do partitioning. # Depending on current payload the storage might be apparently configured # either before or after package/payload installation. # So let's have two task queues - early storage & late storage. early_storage = TaskQueue("Early storage configuration", N_("Configuring storage")) # put custom storage info into ksdata early_storage.append( Task("Insert custom storage to ksdata", storage.update_ksdata)) # pre-storage tasks # - Is this actually needed ? It does not appear to do anything right now. early_storage.append(Task("Run pre-storage tasks", payload.preStorage)) # callbacks for blivet message_clbk = lambda clbk_data: progress_message(clbk_data.msg) step_clbk = lambda clbk_data: progress_step(clbk_data.msg) entropy_wait_clbk = lambda clbk_data: wait_for_entropy( clbk_data.msg, clbk_data.min_entropy, ksdata) callbacks_reg = callbacks.create_new_callbacks_register( create_format_pre=message_clbk, create_format_post=step_clbk, resize_format_pre=message_clbk, resize_format_post=step_clbk, wait_for_entropy=entropy_wait_clbk) early_storage.append( Task("Activate filesystems", task=turn_on_filesystems, task_args=(storage, ), task_kwargs={ "mount_only": flags.flags.dirInstall, "callbacks": callbacks_reg })) early_storage.append(Task("Write early storage", payload.writeStorageEarly)) installation_queue.append(early_storage) # Run %pre-install scripts with the filesystem mounted and no packages pre_install_scripts = TaskQueue("Pre-install scripts", N_("Running pre-installation scripts")) pre_install_scripts.append( Task("Run %pre-install scripts", runPreInstallScripts, (ksdata.scripts, ))) installation_queue.append(pre_install_scripts) # Do packaging. # Discover information about realms to join to determine the need for additional packages. if ksdata.realm.join_realm: realm_discover = TaskQueue("Realm discover", N_("Discovering realm to join")) realm_discover.append( Task("Discover realm to join", ksdata.realm.setup)) installation_queue.append(realm_discover) # Check for other possibly needed additional packages. pre_install = TaskQueue("Pre install tasks", N_("Running pre-installation tasks")) pre_install.append(Task("Setup authconfig", ksdata.authconfig.setup)) pre_install.append(Task("Setup firewall", ksdata.firewall.setup)) pre_install.append(Task("Setup network", ksdata.network.setup)) # Setup timezone and add chrony as package if timezone was set in KS # and "-chrony" wasn't in packages section and/or --nontp wasn't set. pre_install.append( Task("Setup timezone", ksdata.timezone.setup, (ksdata, ))) # make name resolution work for rpm scripts in chroot if flags.can_touch_runtime_system("copy /etc/resolv.conf to sysroot"): # we use a custom Task subclass as the sysroot path has to be resolved # only when the task is actually started, not at task creation time pre_install.append(WriteResolvConfTask("Copy /resolv.conf to sysroot")) def run_pre_install(): """This means to gather what additional packages (if any) are needed & executing payload.preInstall().""" # anaconda requires storage packages in order to make sure the target # system is bootable and configurable, and some other packages in order # to finish setting up the system. packages = storage.packages + ksdata.realm.packages packages += ksdata.authconfig.packages + ksdata.firewall.packages + ksdata.network.packages if willInstallBootloader: packages += storage.bootloader.packages # don't try to install packages from the install class' ignored list and the # explicitly excluded ones (user takes the responsibility) packages = [ p for p in packages if p not in instClass.ignoredPackages and p not in ksdata.packages.excludedList ] payload.preInstall(packages=packages, groups=payload.languageGroups()) pre_install.append( Task("Find additional packages & run preInstall()", run_pre_install)) installation_queue.append(pre_install) payload_install = TaskQueue("Payload installation", N_("Installing.")) payload_install.append(Task("Install the payload", payload.install)) installation_queue.append(payload_install) # for some payloads storage is configured after the payload is installed late_storage = TaskQueue("Late storage configuration", N_("Configuring storage")) late_storage.append(Task("Write late storage", payload.writeStorageLate)) installation_queue.append(late_storage) # Do bootloader. if willInstallBootloader: bootloader_install = TaskQueue("Bootloader installation", N_("Installing boot loader")) bootloader_install.append( Task("Install bootloader", writeBootLoader, (storage, payload, instClass, ksdata))) installation_queue.append(bootloader_install) post_install = TaskQueue("Post-installation setup tasks", (N_("Performing post-installation setup tasks"))) post_install.append( Task("Run post-installation setup tasks", payload.postInstall)) installation_queue.append(post_install) # Create snapshot if ksdata.snapshot and ksdata.snapshot.has_snapshot( SNAPSHOT_WHEN_POST_INSTALL): snapshot_creation = TaskQueue("Creating post installation snapshots", N_("Creating snapshots")) snapshot_creation.append( Task("Create post-install snapshots", ksdata.snapshot.execute, (storage, ksdata, instClass))) installation_queue.append(snapshot_creation) # notify progress tracking about the number of steps progress_init(len(installation_queue)) # log contents of the main task queue log.info(installation_queue.summary) # log tasks and queues when they are started # - note that we are using generators to add the counter queue_counter = iutil.item_counter(installation_queue.queue_count) task_started_counter = iutil.item_counter(installation_queue.task_count) task_completed_counter = iutil.item_counter(installation_queue.task_count) installation_queue.queue_started.connect(lambda x: log.info( "Queue started: %s (%s)", x.name, next(queue_counter))) installation_queue.task_started.connect(lambda x: log.info( "Task started: %s (%s)", x.name, next(task_started_counter))) installation_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 installation_queue.start() # done progress_complete()
def doConfiguration(storage, payload, ksdata, instClass): willWriteNetwork = not flags.flags.imageInstall and not flags.flags.dirInstall willRunRealmd = ksdata.realm.discovered # configure base, create users, configure addons, initramfs, post-install step_count = 5 # network, maybe if willWriteNetwork: step_count += 1 # if a realm was discovered, # increment the counter as the # real joining step will be executed if willRunRealmd: step_count += 1 progress_init(step_count) # Now run the execute methods of ksdata that require an installed system # to be present first. with progress_report(N_("Configuring installed system")): ksdata.authconfig.execute(storage, ksdata, instClass) ksdata.selinux.execute(storage, ksdata, instClass) ksdata.firstboot.execute(storage, ksdata, instClass) ksdata.services.execute(storage, ksdata, instClass) ksdata.keyboard.execute(storage, ksdata, instClass) ksdata.timezone.execute(storage, ksdata, instClass) ksdata.lang.execute(storage, ksdata, instClass) ksdata.firewall.execute(storage, ksdata, instClass) ksdata.xconfig.execute(storage, ksdata, instClass) ksdata.skipx.execute(storage, ksdata, instClass) if willWriteNetwork: with progress_report(N_("Writing network configuration")): ksdata.network.execute(storage, ksdata, instClass) # Creating users and groups requires some pre-configuration. with progress_report(N_("Creating users")): u = Users() ksdata.rootpw.execute(storage, ksdata, instClass, u) ksdata.group.execute(storage, ksdata, instClass, u) ksdata.user.execute(storage, ksdata, instClass, u) ksdata.sshkey.execute(storage, ksdata, instClass, u) with progress_report(N_("Configuring addons")): ksdata.addons.execute(storage, ksdata, instClass, u) with progress_report(N_("Generating initramfs")): payload.recreateInitrds() # Work around rhbz#1200539, grubby doesn't handle grub2 missing initrd with /boot on btrfs # So rerun writing the bootloader if this is live and /boot is on btrfs boot_on_btrfs = isinstance(storage.mountpoints.get("/boot", storage.mountpoints.get("/")), BTRFSDevice) if flags.flags.livecdInstall and boot_on_btrfs \ and (not ksdata.bootloader.disabled and ksdata.bootloader != "none"): writeBootLoader(storage, payload, instClass, ksdata) if willRunRealmd: with progress_report(N_("Joining realm: %s") % ksdata.realm.discovered): ksdata.realm.execute(storage, ksdata, instClass) with progress_report(N_("Running post-installation scripts")): runPostScripts(ksdata.scripts) # setup kexec reboot if requested if flags.flags.kexec: setup_kexec() # 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 copy_kickstarts option.") else: _writeKS(ksdata) progress_complete()
def doInstall(storage, payload, ksdata, instClass): """Perform an installation. This method takes the ksdata as prepared by the UI (the first hub, in graphical mode) and applies it to the disk. The two main tasks for this are putting filesystems onto disks and installing packages onto those filesystems. """ willRunRealmd = ksdata.realm.join_realm willInstallBootloader = not flags.flags.dirInstall and (not ksdata.bootloader.disabled and ksdata.bootloader != "none") # First save system time to HW clock. if flags.can_touch_runtime_system("save system time to HW clock"): timezone.save_hw_clock(ksdata.timezone) # We really only care about actions that affect filesystems, since # those are the ones that take the most time. steps = len(storage.devicetree.findActions(action_type="create", object_type="format")) + \ len(storage.devicetree.findActions(action_type="resize", object_type="format")) # pre setup phase, pre install, post install steps += 3 # realmd, maybe if willRunRealmd: steps += 1 # bootloader, maybe if willInstallBootloader: steps += 1 # This should be the only thread running, wait for the others to finish if not. if threadMgr.running > 1: progress_init(steps+1) with progress_report(_("Waiting for %s threads to finish") % (threadMgr.running-1)): map(log.debug, ("Thread %s is running" % n for n in threadMgr.names)) threadMgr.wait_all() else: progress_init(steps) with progress_report(_("Setting up the installation environment")): ksdata.firstboot.setup(storage, ksdata, instClass) ksdata.addons.setup(storage, ksdata, instClass, payload) # put custom storage info into ksdata, but not if just assigning mount points if not ksdata.mount.dataList(): storage.updateKSData() # Do partitioning. payload.preStorage() # callbacks for blivet message_clbk = lambda clbk_data: progress_message(clbk_data.msg) step_clbk = lambda clbk_data: progress_step(clbk_data.msg) entropy_wait_clbk = lambda clbk_data: wait_for_entropy(clbk_data.msg, clbk_data.min_entropy, ksdata) callbacks_reg = callbacks.create_new_callbacks_register(create_format_pre=message_clbk, create_format_post=step_clbk, resize_format_pre=message_clbk, resize_format_post=step_clbk, wait_for_entropy=entropy_wait_clbk) turnOnFilesystems(storage, mountOnly=flags.flags.dirInstall, callbacks=callbacks_reg) write_storage_late = (flags.flags.livecdInstall or ksdata.ostreesetup.seen or ksdata.method.method == "liveimg") if not write_storage_late and not flags.flags.dirInstall: storage.write() # # STACKI # # Check to see if we're running as a frontend # import os file = open('/proc/cmdline', 'r') args = file.readline().split() file.close() if 'frontend' in args: # If /export does not exist, create a symlink # to /state/partition1. If /state/partition1 doesn't # exist either, just ignore if not os.path.exists('/mnt/sysimage/export'): if os.path.exists('/mnt/sysimage/state/partition1'): pwd = os.getcwd() os.chdir('/mnt/sysimage') os.symlink('state/partition1', 'export') os.chdir(pwd) # Enable all known repos for repo in payload._yum.repos.repos.values(): payload.enableRepo(repo.id) log.debug('STACKI: repo.id (%s) - %s' % (repo.id, repo.isEnabled())) else: # # need to setup a symbolic link in order to store all the packages # downloaded by lighttpd # cmd = 'rm -rf /install ; ' cmd += 'mkdir -p /mnt/sysimage/install ; ' cmd += 'ln -s /mnt/sysimage/install /install' os.system(cmd) # STACKI # Run %pre-install scripts with the filesystem mounted and no packages with progress_report(_("Running pre-installation scripts")): runPreInstallScripts(ksdata.scripts) # Do packaging. # Discover information about realms to join, # to determine additional packages if willRunRealmd: with progress_report(_("Discovering realm to join")): ksdata.realm.setup() # make name resolution work for rpm scripts in chroot if flags.can_touch_runtime_system("copy /etc/resolv.conf to sysroot"): network.copyFileToPath("/etc/resolv.conf", iutil.getSysroot()) # Check for additional packages ksdata.authconfig.setup() ksdata.firewall.setup() # Setup timezone and add chrony as package if timezone was set in KS # and "-chrony" wasn't in packages section and/or --nontp wasn't set. ksdata.timezone.setup(ksdata) # anaconda requires storage packages in order to make sure the target # system is bootable and configurable, and some other packages in order # to finish setting up the system. packages = storage.packages + ksdata.realm.packages packages += ksdata.authconfig.packages + ksdata.firewall.packages if willInstallBootloader: packages += storage.bootloader.packages if network.is_using_team_device(): packages.append("teamd") # don't try to install packages from the install class' ignored list and the # explicitly excluded ones (user takes the responsibility) packages = [p for p in packages if p not in instClass.ignoredPackages and p not in ksdata.packages.excludedList] payload.preInstall(packages=packages, groups=payload.languageGroups()) payload.install() if write_storage_late and not flags.flags.dirInstall: if iutil.getSysroot() != iutil.getTargetPhysicalRoot(): blivet.setSysroot(iutil.getTargetPhysicalRoot(), iutil.getSysroot()) # Note this changed for RHEL 7.5; see comments in rpmostreepayload.py. payload.prepareMountTargets(storage) storage.write() # Do bootloader. if willInstallBootloader: with progress_report(_("Installing boot loader")): writeBootLoader(storage, payload, instClass, ksdata) with progress_report(_("Performing post-installation setup tasks")): payload.postInstall() progress_complete()
def doInstall(storage, payload, ksdata, instClass): """Perform an installation. This method takes the ksdata as prepared by the UI (the first hub, in graphical mode) and applies it to the disk. The two main tasks for this are putting filesystems onto disks and installing packages onto those filesystems. """ willRunRealmd = ksdata.realm.join_realm willInstallBootloader = not flags.flags.dirInstall and (not ksdata.bootloader.disabled and ksdata.bootloader != "none") # First save system time to HW clock. if flags.can_touch_runtime_system("save system time to HW clock"): timezone.save_hw_clock(ksdata.timezone) # We really only care about actions that affect filesystems, since # those are the ones that take the most time. steps = len(storage.devicetree.findActions(action_type="create", object_type="format")) + \ len(storage.devicetree.findActions(action_type="resize", object_type="format")) # pre setup phase, post install steps += 2 # realmd, maybe if willRunRealmd: steps += 1 # bootloader, maybe if willInstallBootloader: steps += 1 # This should be the only thread running, wait for the others to finish if not. if threadMgr.running > 1: progress_init(steps+1) with progress_report(_("Waiting for %s threads to finish") % (threadMgr.running-1)): map(log.debug, ("Thread %s is running" % n for n in threadMgr.names)) threadMgr.wait_all() else: progress_init(steps) with progress_report(_("Setting up the installation environment")): ksdata.firstboot.setup(storage, ksdata, instClass) ksdata.addons.setup(storage, ksdata, instClass) storage.updateKSData() # this puts custom storage info into ksdata # Do partitioning. payload.preStorage() # callbacks for blivet message_clbk = lambda clbk_data: progress_message(clbk_data.msg) step_clbk = lambda clbk_data: progress_step(clbk_data.msg) entropy_wait_clbk = lambda clbk_data: wait_for_entropy(clbk_data.msg, clbk_data.min_entropy, ksdata) callbacks_reg = callbacks.create_new_callbacks_register(create_format_pre=message_clbk, create_format_post=step_clbk, resize_format_pre=message_clbk, resize_format_post=step_clbk, wait_for_entropy=entropy_wait_clbk) turnOnFilesystems(storage, mountOnly=flags.flags.dirInstall, callbacks=callbacks_reg) write_storage_late = (flags.flags.livecdInstall or ksdata.ostreesetup.seen or ksdata.method.method == "liveimg") if not write_storage_late and not flags.flags.dirInstall: storage.write() # STACKI file = open('/proc/cmdline', 'r') args = file.readline().split() file.close() if 'boss' in args: import subprocess import os # # if we are a boss, then download the selected rolls # log.debug('STACKI: Downloading pallets: start') bossenv = os.environ.copy() bossenv['LD_LIBRARY_PATH'] = '/opt/stack/lib' bossenv['DISPLAY'] = ':1' s = subprocess.Popen('/opt/stack/bin/boss_download_pallets.py', env = bossenv) s.wait() log.debug('STACKI: Downloading pallets: complete') payload.reset() # # # for repo in payload._yum.repos.repos.values(): log.debug('STACKI: repo.id (%s)' % repo.id) # if repo.id not in [ 'stacki', 'os' ]: # log.debug('STACKI: disabling repo repo.id (%s)' % repo.id) # payload.disableRepo(repo.id) else: # # need to setup a symbolic link in order to store all the packages # downloaded by lighttpd # import os cmd = 'rm -rf /install ; ' cmd += 'mkdir -p /mnt/sysimage/install ; ' cmd += 'ln -s /mnt/sysimage/install /install' os.system(cmd) # STACKI # Do packaging. # Discover information about realms to join, # to determine additional packages if willRunRealmd: with progress_report(_("Discovering realm to join")): ksdata.realm.setup() # make name resolution work for rpm scripts in chroot if flags.can_touch_runtime_system("copy /etc/resolv.conf to sysroot"): network.copyFileToPath("/etc/resolv.conf", iutil.getSysroot()) # Check for additional packages ksdata.authconfig.setup() ksdata.firewall.setup() # anaconda requires storage packages in order to make sure the target # system is bootable and configurable, and some other packages in order # to finish setting up the system. packages = storage.packages + ksdata.realm.packages packages += ksdata.authconfig.packages + ksdata.firewall.packages if willInstallBootloader: packages += storage.bootloader.packages if network.is_using_team_device(): packages.append("teamd") # don't try to install packages from the install class' ignored list and the # explicitly excluded ones (user takes the responsibility) packages = [p for p in packages if p not in instClass.ignoredPackages and p not in ksdata.packages.excludedList] payload.preInstall(packages=packages, groups=payload.languageGroups()) payload.install() if write_storage_late and not flags.flags.dirInstall: if iutil.getSysroot() != iutil.getTargetPhysicalRoot(): blivet.setSysroot(iutil.getTargetPhysicalRoot(), iutil.getSysroot()) # Now that we have the FS layout in the target, umount # things that were in the legacy sysroot, and put them in # the target root, except for the physical /. First, # unmount all target filesystems. storage.umountFilesystems() # Explicitly mount the root on the physical sysroot rootmnt = storage.mountpoints.get('/') rootmnt.setup() rootmnt.format.setup(options=rootmnt.format.options, chroot=iutil.getTargetPhysicalRoot()) payload.prepareMountTargets(storage) # Everything else goes in the target root, including /boot # since the bootloader code will expect to find /boot # inside the chroot. storage.mountFilesystems(skipRoot=True) storage.write() # Do bootloader. if willInstallBootloader: with progress_report(_("Installing boot loader")): writeBootLoader(storage, payload, instClass, ksdata) with progress_report(_("Performing post-installation setup tasks")): payload.postInstall() progress_complete()
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 doInstall(storage, payload, ksdata, instClass): """Perform an installation. This method takes the ksdata as prepared by the UI (the first hub, in graphical mode) and applies it to the disk. The two main tasks for this are putting filesystems onto disks and installing packages onto those filesystems. """ willRunRealmd = ksdata.realm.join_realm willInstallBootloader = not flags.flags.dirInstall and ( not ksdata.bootloader.disabled and ksdata.bootloader != "none") # First save system time to HW clock. if flags.can_touch_runtime_system("save system time to HW clock"): timezone.save_hw_clock(ksdata.timezone) # We really only care about actions that affect filesystems, since # those are the ones that take the most time. steps = len(storage.devicetree.findActions(action_type="create", object_type="format")) + \ len(storage.devicetree.findActions(action_type="resize", object_type="format")) # pre setup phase, pre install, post install steps += 3 # realmd, maybe if willRunRealmd: steps += 1 # bootloader, maybe if willInstallBootloader: steps += 1 # This should be the only thread running, wait for the others to finish if not. if threadMgr.running > 1: progress_init(steps + 1) with progress_report( _("Waiting for %s threads to finish") % (threadMgr.running - 1)): map(log.debug, ("Thread %s is running" % n for n in threadMgr.names)) threadMgr.wait_all() else: progress_init(steps) with progress_report(_("Setting up the installation environment")): ksdata.firstboot.setup(storage, ksdata, instClass) ksdata.addons.setup(storage, ksdata, instClass, payload) storage.updateKSData() # this puts custom storage info into ksdata # Do partitioning. payload.preStorage() # callbacks for blivet message_clbk = lambda clbk_data: progress_message(clbk_data.msg) step_clbk = lambda clbk_data: progress_step(clbk_data.msg) entropy_wait_clbk = lambda clbk_data: wait_for_entropy( clbk_data.msg, clbk_data.min_entropy, ksdata) callbacks_reg = callbacks.create_new_callbacks_register( create_format_pre=message_clbk, create_format_post=step_clbk, resize_format_pre=message_clbk, resize_format_post=step_clbk, wait_for_entropy=entropy_wait_clbk) turnOnFilesystems(storage, mountOnly=flags.flags.dirInstall, callbacks=callbacks_reg) write_storage_late = (flags.flags.livecdInstall or ksdata.ostreesetup.seen or ksdata.method.method == "liveimg") if not write_storage_late and not flags.flags.dirInstall: storage.write() # Run %pre-install scripts with the filesystem mounted and no packages with progress_report(_("Running pre-installation scripts")): runPreInstallScripts(ksdata.scripts) # Do packaging. # Discover information about realms to join, # to determine additional packages if willRunRealmd: with progress_report(_("Discovering realm to join")): ksdata.realm.setup() # make name resolution work for rpm scripts in chroot if flags.can_touch_runtime_system("copy /etc/resolv.conf to sysroot"): network.copyFileToPath("/etc/resolv.conf", iutil.getSysroot()) # Check for additional packages ksdata.authconfig.setup() ksdata.firewall.setup() # Setup timezone and add chrony as package if timezone was set in KS # and "-chrony" wasn't in packages section and/or --nontp wasn't set. ksdata.timezone.setup(ksdata) # anaconda requires storage packages in order to make sure the target # system is bootable and configurable, and some other packages in order # to finish setting up the system. packages = storage.packages + ksdata.realm.packages packages += ksdata.authconfig.packages + ksdata.firewall.packages if willInstallBootloader: packages += storage.bootloader.packages if network.is_using_team_device(): packages.append("teamd") # don't try to install packages from the install class' ignored list and the # explicitly excluded ones (user takes the responsibility) packages = [ p for p in packages if p not in instClass.ignoredPackages and p not in ksdata.packages.excludedList ] payload.preInstall(packages=packages, groups=payload.languageGroups()) payload.install() if write_storage_late and not flags.flags.dirInstall: if iutil.getSysroot() != iutil.getTargetPhysicalRoot(): blivet.setSysroot(iutil.getTargetPhysicalRoot(), iutil.getSysroot()) # Now that we have the FS layout in the target, umount # things that were in the legacy sysroot, and put them in # the target root, except for the physical /. First, # unmount all target filesystems. storage.umountFilesystems() # Explicitly mount the root on the physical sysroot rootmnt = storage.mountpoints.get('/') rootmnt.setup() rootmnt.format.setup(options=rootmnt.format.options, chroot=iutil.getTargetPhysicalRoot()) payload.prepareMountTargets(storage) # Everything else goes in the target root, including /boot # since the bootloader code will expect to find /boot # inside the chroot. storage.mountFilesystems(skipRoot=True) storage.write() # Do bootloader. if willInstallBootloader: with progress_report(_("Installing boot loader")): writeBootLoader(storage, payload, instClass, ksdata) with progress_report(_("Performing post-installation setup tasks")): payload.postInstall() progress_complete()