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")):
if 0: # sabayon
# authconfig causes massive breakage to Gentoo's pambase file
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)
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(_("Configuring system")):
payload.configure()
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, 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"))
# 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):
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 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.
"""
# 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(type="create", object="format")) + \
len(storage.devicetree.findActions(type="resize", object="format"))
steps += 6
# pre setup phase, packages setup, packages, bootloader, realmd,
# post install
progressQ.send_init(steps)
# This should be the only thread running, wait for the others to finish if not.
if threadMgr.running > 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()
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()
turnOnFilesystems(storage, mountOnly=flags.flags.dirInstall)
if not flags.flags.livecdInstall and not flags.flags.dirInstall:
storage.write()
# Do packaging.
# Discover information about realms to join,
# to determine additional packages
if ksdata.realm.join_realm:
with progress_report(_("Discovering realm to join")):
ksdata.realm.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
packages += ["net-firewall/firewalld"]
packages += ksdata.realm.packages
# don't try to install packages from the install class' ignored list
packages = [p for p in packages if p not in instClass.ignoredPackages]
payload.preInstall(packages=packages, groups=payload.languageGroups())
payload.install()
if flags.flags.livecdInstall:
storage.write()
with progress_report(_("Performing post-installation setup tasks")):
payload.postInstall()
# Do bootloader.
if not flags.flags.dirInstall:
with progress_report(_("Installing bootloader")):
writeBootLoader(storage, payload, instClass, ksdata)
progressQ.send_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.
"""
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, 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.
"""
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.actions.find(action_type="create", object_type="format")) + \
len(storage.devicetree.actions.find(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, payload)
storage.update_ksdata() # 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)
turn_on_filesystems(storage,
mount_only=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):
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.
"""
# 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(type="create", object="format")) + \
len(storage.devicetree.findActions(type="resize", object="format"))
steps += 6
# pre setup phase, packages setup, packages, bootloader, realmd,
# post install
progressQ.send_init(steps)
# This should be the only thread running, wait for the others to finish if not.
if threadMgr.running > 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()
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()
turnOnFilesystems(storage, mountOnly=flags.flags.dirInstall)
if not flags.flags.livecdInstall and not flags.flags.dirInstall:
storage.write()
# Do packaging.
# Discover information about realms to join,
# to determine additional packages
if ksdata.realm.join_realm:
with progress_report(_("Discovering realm to join")):
ksdata.realm.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 + ["authconfig", "firewalld"
] + ksdata.realm.packages
# don't try to install packages from the install class' ignored list
packages = [p for p in packages if p not in instClass.ignoredPackages]
payload.preInstall(packages=packages, groups=payload.languageGroups())
payload.install()
if flags.flags.livecdInstall:
storage.write()
with progress_report(_("Performing post-installation setup tasks")):
payload.postInstall()
# Do bootloader.
if not flags.flags.dirInstall:
with progress_report(_("Installing bootloader")):
writeBootLoader(storage, payload, instClass, ksdata)
progressQ.send_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 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):
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")):
if 0: # sabayon
# authconfig causes massive breakage to Gentoo's pambase file
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)
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(_("Configuring system")):
payload.configure()
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 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()
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)
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)
# Write the kickstart file to the installed system (or, copy the input
# kickstart file over if one exists).
_writeKS(ksdata)
progress_complete()