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
