def _apply(self): # Do not execute sections that were part of the original # anaconda kickstart file (== have .seen flag set) log.info("applying changes") sections = [self.data.keyboard, self.data.lang, self.data.timezone] # data.selinux # data.firewall log.info("executing kickstart") for section in sections: section_msg = "%s on line %d" % (repr(section), section.lineno) if section.seen: log.debug("skipping %s", section_msg) continue log.debug("executing %s", section_msg) section.execute(None, self.data, None) # Prepare the user database tools u = Users() sections = [self.data.group, self.data.user, self.data.rootpw] for section in sections: section_msg = "%s on line %d" % (repr(section), section.lineno) if section.seen: log.debug("skipping %s", section_msg) continue log.debug("executing %s", section_msg) section.execute(None, self.data, None, u) # Configure all addons log.info("executing addons") self.data.addons.execute(None, self.data, None, u, None) if self.external_reconfig: # prevent the reconfig flag from being written out # to kickstart if neither /etc/reconfigSys or /.unconfigured # are present self.data.firstboot.firstboot = None # Write the kickstart data to file log.info("writing the Initial Setup kickstart file %s", OUTPUT_KICKSTART_PATH) with open(OUTPUT_KICKSTART_PATH, "w") as f: f.write(str(self.data)) log.info("finished writing the Initial Setup kickstart file") # Remove the reconfig files, if any - otherwise the reconfig mode # would start again next time the Initial Setup service is enabled. if self.external_reconfig: for reconfig_file in RECONFIG_FILES: if os.path.exists(reconfig_file): log.debug("removing reconfig trigger file: %s" % reconfig_file) os.remove(reconfig_file) # and we are done with applying changes log.info("all changes have been applied")
def doConfiguration(storage, payload, ksdata, instClass): from pyanaconda.kickstart import runPostScripts step_count = 6 # if a realm was discovered, # increment the counter as the # real joining step will be executed if ksdata.realm.discovered: step_count += 1 progressQ.send_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 not flags.flags.imageInstall and not flags.flags.dirInstall: 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(ROOT_PATH, 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) ksdata.configured_spokes.execute(storage, ksdata, instClass, u) with progress_report(_("Generating initramfs")): payload.recreateInitrds(force=True) if ksdata.realm.discovered: 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) progressQ.send_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 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 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 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()
sections = [data.keyboard, data.lang, data.timezone] # data.selinux # data.firewall log.info("executing kickstart") for section in sections: section_msg = "%s on line %d" % (repr(section), section.lineno) if section.seen: log.debug("skipping %s", section_msg) continue log.debug("executing %s", section_msg) section.execute(None, data, None) # Prepare the user database tools u = Users() sections = [data.group, data.user, data.rootpw] for section in sections: section_msg = "%s on line %d" % (repr(section), section.lineno) if section.seen: log.debug("skipping %s", section_msg) continue log.debug("executing %s", section_msg) section.execute(None, data, None, u) # Configure all addons log.info("executing addons") data.addons.execute(None, data, None, u) # Write the kickstart data to file