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