562 lines
22 KiB
Python
562 lines
22 KiB
Python
|
# install.py
|
||
|
|
# Do the hard work of performing an installation.
|
||
|
|
#
|
||
|
|
# Copyright (C) 2012 Red Hat, Inc.
|
||
|
|
#
|
||
|
|
# This copyrighted material is made available to anyone wishing to use,
|
||
|
|
# modify, copy, or redistribute it subject to the terms and conditions of
|
||
|
|
# the GNU General Public License v.2, or (at your option) any later version.
|
||
|
|
# This program is distributed in the hope that it will be useful, but WITHOUT
|
||
|
|
# ANY WARRANTY expressed or implied, including the implied warranties of
|
||
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
|
||
|
|
# Public License for more details. You should have received a copy of the
|
||
|
|
# GNU General Public License along with this program; if not, write to the
|
||
|
|
# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
||
|
|
# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the
|
||
|
|
# source code or documentation are not subject to the GNU General Public
|
||
|
|
# License and may only be used or replicated with the express permission of
|
||
|
|
# Red Hat, Inc.
|
||
|
|
#
|
||
|
|
from pyanaconda.core.dbus import DBus
|
||
|
|
from pyanaconda.core.configuration.anaconda import conf
|
||
|
|
from pyanaconda.core.constants import PAYLOAD_LIVE_TYPES, PAYLOAD_TYPE_DNF, CATEGORY_SYSTEM, \
|
||
|
|
CATEGORY_BOOTLOADER, CATEGORY_ENVIRONMENT, CATEGORY_STORAGE, CATEGORY_SOFTWARE
|
||
|
|
from pyanaconda.modules.boss.install_manager.installation_category_interface \
|
||
|
|
import CategoryReportTaskInterface
|
||
|
|
from pyanaconda.modules.common.constants.objects import BOOTLOADER, SNAPSHOT, FIREWALL
|
||
|
|
from pyanaconda.modules.common.constants.services import STORAGE, USERS, SERVICES, NETWORK, \
|
||
|
|
SECURITY, LOCALIZATION, TIMEZONE, BOSS, SUBSCRIPTION
|
||
|
|
from pyanaconda.modules.common.task import sync_run_task, Task as InstallationTask
|
||
|
|
from pyanaconda.modules.common.util import is_module_available
|
||
|
|
from pyanaconda import flags
|
||
|
|
from pyanaconda.core import util
|
||
|
|
from pyanaconda.core.path import open_with_perm
|
||
|
|
from pyanaconda.core.service import is_service_installed
|
||
|
|
from pyanaconda import network
|
||
|
|
from pyanaconda.core.i18n import _
|
||
|
|
from pyanaconda.core.threads import thread_manager
|
||
|
|
from pyanaconda.kickstart import runPostScripts, runPreInstallScripts
|
||
|
|
from pyanaconda.kexec import setup_kexec
|
||
|
|
from pyanaconda.installation_tasks import Task, TaskQueue, DBusTask
|
||
|
|
from pykickstart.constants import SNAPSHOT_WHEN_POST_INSTALL
|
||
|
|
|
||
|
|
from pyanaconda.anaconda_loggers import get_module_logger
|
||
|
|
log = get_module_logger(__name__)
|
||
|
|
|
||
|
|
__all__ = ["RunInstallationTask"]
|
||
|
|
|
||
|
|
|
||
|
|
def _writeKS(ksdata):
|
||
|
|
path = conf.target.system_root + "/root/anaconda-ks.cfg"
|
||
|
|
|
||
|
|
# Make it so only root can read - could have passwords
|
||
|
|
with open_with_perm(path, "w", 0o600) as f:
|
||
|
|
f.write("# Generated by Anaconda {}\n".format(util.get_anaconda_version_string()))
|
||
|
|
f.write(str(ksdata))
|
||
|
|
|
||
|
|
class RunInstallationTask(InstallationTask):
|
||
|
|
"""Task to run the installation queue."""
|
||
|
|
|
||
|
|
def __init__(self, payload, ksdata):
|
||
|
|
"""Create a new task.
|
||
|
|
|
||
|
|
:param payload: the payload object
|
||
|
|
:param ksdata: the kickstart data
|
||
|
|
"""
|
||
|
|
super().__init__()
|
||
|
|
self._payload = payload
|
||
|
|
self._ksdata = ksdata
|
||
|
|
self._total_steps = 0
|
||
|
|
|
||
|
|
@property
|
||
|
|
def name(self):
|
||
|
|
"""Name of the task"""
|
||
|
|
return "Run the installation queue."
|
||
|
|
|
||
|
|
@property
|
||
|
|
def steps(self):
|
||
|
|
"""Total number of steps."""
|
||
|
|
return self._total_steps
|
||
|
|
|
||
|
|
def run(self):
|
||
|
|
"""Run the task."""
|
||
|
|
self._run_installation(
|
||
|
|
payload=self._payload,
|
||
|
|
ksdata=self._ksdata,
|
||
|
|
)
|
||
|
|
|
||
|
|
def for_publication(self):
|
||
|
|
"""Return a DBus representation."""
|
||
|
|
return CategoryReportTaskInterface(self)
|
||
|
|
|
||
|
|
def _queue_started_cb(self, task):
|
||
|
|
"""The installation queue was started."""
|
||
|
|
self.report_category(task.task_category)
|
||
|
|
self.report_progress(task.status_message)
|
||
|
|
|
||
|
|
def _task_completed_cb(self, task):
|
||
|
|
"""The installation task was completed."""
|
||
|
|
self.report_progress("", step_size=1)
|
||
|
|
|
||
|
|
def _progress_report_cb(self, step, message):
|
||
|
|
"""Handle a progress report of a task."""
|
||
|
|
self.report_progress(message)
|
||
|
|
|
||
|
|
def _prepare_configuration(self, payload, ksdata):
|
||
|
|
"""Configure the installed system."""
|
||
|
|
configuration_queue = TaskQueue("Configuration queue")
|
||
|
|
|
||
|
|
# connect progress reporting
|
||
|
|
configuration_queue.queue_started.connect(self._queue_started_cb)
|
||
|
|
configuration_queue.task_completed.connect(self._task_completed_cb)
|
||
|
|
|
||
|
|
# add installation tasks for the Subscription DBus module
|
||
|
|
if is_module_available(SUBSCRIPTION):
|
||
|
|
# we only run the tasks if the Subscription module is available
|
||
|
|
subscription_config = TaskQueue(
|
||
|
|
"Subscription configuration",
|
||
|
|
_("Configuring Red Hat subscription"),
|
||
|
|
CATEGORY_SYSTEM
|
||
|
|
)
|
||
|
|
subscription_proxy = SUBSCRIPTION.get_proxy()
|
||
|
|
subscription_dbus_tasks = subscription_proxy.InstallWithTasks()
|
||
|
|
subscription_config.append_dbus_tasks(SUBSCRIPTION, subscription_dbus_tasks)
|
||
|
|
configuration_queue.append(subscription_config)
|
||
|
|
|
||
|
|
# schedule the execute methods of ksdata that require an installed system to be present
|
||
|
|
os_config = TaskQueue(
|
||
|
|
"Installed system configuration",
|
||
|
|
_("Configuring installed system"),
|
||
|
|
CATEGORY_SYSTEM
|
||
|
|
)
|
||
|
|
|
||
|
|
# add installation tasks for the Security DBus module
|
||
|
|
if is_module_available(SECURITY):
|
||
|
|
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 Timezone DBus module
|
||
|
|
# run these tasks before tasks of the Services module
|
||
|
|
if is_module_available(TIMEZONE):
|
||
|
|
timezone_proxy = TIMEZONE.get_proxy()
|
||
|
|
timezone_dbus_tasks = timezone_proxy.InstallWithTasks()
|
||
|
|
os_config.append_dbus_tasks(TIMEZONE, timezone_dbus_tasks)
|
||
|
|
|
||
|
|
# add installation tasks for the Services DBus module
|
||
|
|
if is_module_available(SERVICES):
|
||
|
|
services_proxy = SERVICES.get_proxy()
|
||
|
|
services_dbus_tasks = services_proxy.InstallWithTasks()
|
||
|
|
os_config.append_dbus_tasks(SERVICES, services_dbus_tasks)
|
||
|
|
|
||
|
|
# add installation tasks for the Localization DBus module
|
||
|
|
if is_module_available(LOCALIZATION):
|
||
|
|
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
|
||
|
|
if conf.target.can_configure_network:
|
||
|
|
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.target.can_configure_network and conf.system.provides_network_config:
|
||
|
|
overwrite = payload.type in PAYLOAD_LIVE_TYPES
|
||
|
|
network_config = TaskQueue(
|
||
|
|
"Network configuration",
|
||
|
|
_("Writing network configuration"),
|
||
|
|
CATEGORY_SYSTEM
|
||
|
|
)
|
||
|
|
network_config.append(Task(
|
||
|
|
"Network configuration",
|
||
|
|
network.write_configuration,
|
||
|
|
(overwrite, )
|
||
|
|
))
|
||
|
|
configuration_queue.append(network_config)
|
||
|
|
|
||
|
|
# add installation tasks for the Users DBus module
|
||
|
|
if is_module_available(USERS):
|
||
|
|
user_config = TaskQueue(
|
||
|
|
"User creation",
|
||
|
|
_("Creating users"),
|
||
|
|
CATEGORY_SYSTEM
|
||
|
|
)
|
||
|
|
users_proxy = USERS.get_proxy()
|
||
|
|
users_dbus_tasks = users_proxy.InstallWithTasks()
|
||
|
|
user_config.append_dbus_tasks(USERS, users_dbus_tasks)
|
||
|
|
configuration_queue.append(user_config)
|
||
|
|
|
||
|
|
# Anaconda addon configuration
|
||
|
|
addon_config = TaskQueue(
|
||
|
|
"Anaconda addon configuration",
|
||
|
|
_("Configuring addons"),
|
||
|
|
CATEGORY_SYSTEM
|
||
|
|
)
|
||
|
|
|
||
|
|
boss_proxy = BOSS.get_proxy()
|
||
|
|
for service_name, object_path in boss_proxy.CollectInstallSystemTasks():
|
||
|
|
task_proxy = DBus.get_proxy(service_name, object_path)
|
||
|
|
addon_config.append(DBusTask(task_proxy))
|
||
|
|
|
||
|
|
configuration_queue.append(addon_config)
|
||
|
|
|
||
|
|
# Initramfs generation
|
||
|
|
generate_initramfs = TaskQueue(
|
||
|
|
"Initramfs generation",
|
||
|
|
_("Generating initramfs"),
|
||
|
|
CATEGORY_BOOTLOADER
|
||
|
|
)
|
||
|
|
bootloader_proxy = STORAGE.get_proxy(BOOTLOADER)
|
||
|
|
|
||
|
|
def run_generate_initramfs():
|
||
|
|
tasks = bootloader_proxy.GenerateInitramfsWithTasks(
|
||
|
|
payload.type,
|
||
|
|
payload.kernel_version_list
|
||
|
|
)
|
||
|
|
|
||
|
|
for task in tasks:
|
||
|
|
sync_run_task(STORAGE.get_proxy(task))
|
||
|
|
|
||
|
|
generate_initramfs.append(Task(
|
||
|
|
"Generate initramfs",
|
||
|
|
run_generate_initramfs
|
||
|
|
))
|
||
|
|
configuration_queue.append(generate_initramfs)
|
||
|
|
|
||
|
|
if is_module_available(SECURITY):
|
||
|
|
security_proxy = SECURITY.get_proxy()
|
||
|
|
|
||
|
|
# Configure FIPS.
|
||
|
|
configuration_queue.append_dbus_tasks(SECURITY, [
|
||
|
|
security_proxy.ConfigureFIPSWithTask()
|
||
|
|
])
|
||
|
|
|
||
|
|
# Join a realm. This can run only after network
|
||
|
|
# is configured in the target system chroot.
|
||
|
|
configuration_queue.append_dbus_tasks(SECURITY, [
|
||
|
|
security_proxy.JoinRealmWithTask()
|
||
|
|
])
|
||
|
|
|
||
|
|
# Calling zipl should be the last task on s390
|
||
|
|
configuration_queue.append_dbus_tasks(STORAGE, [
|
||
|
|
bootloader_proxy.FixZIPLBootloaderWithTask()
|
||
|
|
])
|
||
|
|
|
||
|
|
# setup kexec reboot if requested
|
||
|
|
if flags.flags.kexec:
|
||
|
|
kexec_setup = TaskQueue(
|
||
|
|
"Kexec setup",
|
||
|
|
_("Setting up kexec"),
|
||
|
|
CATEGORY_BOOTLOADER
|
||
|
|
)
|
||
|
|
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",
|
||
|
|
_("Storing configuration files and kickstarts"),
|
||
|
|
CATEGORY_SYSTEM
|
||
|
|
)
|
||
|
|
|
||
|
|
# Write the kickstart file to the installed system (or, copy the input
|
||
|
|
# kickstart file over if one exists).
|
||
|
|
if conf.target.can_save_output_kickstart:
|
||
|
|
# write anaconda related configs & kickstarts
|
||
|
|
write_configs.append(Task("Store kickstarts", _writeKS, (ksdata,)))
|
||
|
|
else:
|
||
|
|
# 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.")
|
||
|
|
|
||
|
|
# 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)
|
||
|
|
|
||
|
|
post_scripts = TaskQueue(
|
||
|
|
"Post installation scripts",
|
||
|
|
_("Running post-installation scripts"),
|
||
|
|
CATEGORY_SYSTEM
|
||
|
|
)
|
||
|
|
post_scripts.append(Task(
|
||
|
|
"Run post installation scripts",
|
||
|
|
runPostScripts,
|
||
|
|
(ksdata.scripts,)
|
||
|
|
))
|
||
|
|
configuration_queue.append(post_scripts)
|
||
|
|
|
||
|
|
boss_proxy = BOSS.get_proxy()
|
||
|
|
finish_tasks = boss_proxy.FinishInstallationWithTasks()
|
||
|
|
configuration_queue.append_dbus_tasks(BOSS, finish_tasks)
|
||
|
|
|
||
|
|
return configuration_queue
|
||
|
|
|
||
|
|
def _wait_for_threads_to_finish(self):
|
||
|
|
"""Wait for background processing threads to finish.
|
||
|
|
|
||
|
|
Wait for background processing threads to finish before filling
|
||
|
|
the installation task queue. Otherwise installation tasks might
|
||
|
|
be created based on old data in DBus modules, missing data set by
|
||
|
|
the threads that are still running.
|
||
|
|
"""
|
||
|
|
|
||
|
|
# This should be the only thread running, wait for the others to finish if not.
|
||
|
|
if thread_manager.running > 1:
|
||
|
|
# show a progress message
|
||
|
|
self.report_progress(_("Waiting for %s threads to finish") % (thread_manager.running - 1))
|
||
|
|
for message in ("Thread %s is running" % n for n in thread_manager.names):
|
||
|
|
log.debug(message)
|
||
|
|
thread_manager.wait_all()
|
||
|
|
log.debug("No more threads are running, assembling installation task queue.")
|
||
|
|
|
||
|
|
def _prepare_installation(self, payload, ksdata):
|
||
|
|
"""Perform an installation. This method takes the ksdata as prepared by
|
||
|
|
the UI (the first hub, in graphical mode) and applies it to the disk.
|
||
|
|
The two main tasks for this are putting filesystems onto disks and
|
||
|
|
installing packages onto those filesystems.
|
||
|
|
"""
|
||
|
|
installation_queue = TaskQueue("Installation queue")
|
||
|
|
|
||
|
|
# connect progress reporting
|
||
|
|
installation_queue.queue_started.connect(self._queue_started_cb)
|
||
|
|
installation_queue.task_completed.connect(self._task_completed_cb)
|
||
|
|
|
||
|
|
# setup the installation environment
|
||
|
|
setup_environment = TaskQueue(
|
||
|
|
"Installation environment setup",
|
||
|
|
_("Setting up the installation environment"),
|
||
|
|
CATEGORY_ENVIRONMENT
|
||
|
|
)
|
||
|
|
|
||
|
|
boss_proxy = BOSS.get_proxy()
|
||
|
|
for service_name, object_path in boss_proxy.CollectConfigureRuntimeTasks():
|
||
|
|
task_proxy = DBus.get_proxy(service_name, object_path)
|
||
|
|
setup_environment.append(DBusTask(task_proxy))
|
||
|
|
|
||
|
|
# Add configuration tasks for the Localization DBus module.
|
||
|
|
if is_module_available(LOCALIZATION):
|
||
|
|
localization_proxy = LOCALIZATION.get_proxy()
|
||
|
|
# Populate the missing keyboard values before the payload installation,
|
||
|
|
# so the module requirements can be generated for the right configuration.
|
||
|
|
# FIXME: Make sure that the module always returns right values.
|
||
|
|
populate_task = localization_proxy.PopulateMissingKeyboardConfigurationWithTask()
|
||
|
|
setup_environment.append_dbus_tasks(LOCALIZATION, [populate_task])
|
||
|
|
|
||
|
|
installation_queue.append(setup_environment)
|
||
|
|
|
||
|
|
# Do partitioning.
|
||
|
|
# Depending on current payload the storage might be apparently configured
|
||
|
|
# either before or after package/payload installation.
|
||
|
|
# So let's have two task queues - early storage & late storage.
|
||
|
|
storage_proxy = STORAGE.get_proxy()
|
||
|
|
early_storage = TaskQueue(
|
||
|
|
"Early storage configuration",
|
||
|
|
_("Configuring storage"),
|
||
|
|
CATEGORY_STORAGE
|
||
|
|
)
|
||
|
|
early_storage.append_dbus_tasks(STORAGE, storage_proxy.InstallWithTasks())
|
||
|
|
|
||
|
|
if payload.type == PAYLOAD_TYPE_DNF:
|
||
|
|
conf_task = storage_proxy.WriteConfigurationWithTask()
|
||
|
|
early_storage.append_dbus_tasks(STORAGE, [conf_task])
|
||
|
|
|
||
|
|
installation_queue.append(early_storage)
|
||
|
|
|
||
|
|
# Run %pre-install scripts with the filesystem mounted and no packages
|
||
|
|
pre_install_scripts = TaskQueue(
|
||
|
|
"Pre-install scripts",
|
||
|
|
_("Running pre-installation scripts"),
|
||
|
|
CATEGORY_ENVIRONMENT
|
||
|
|
)
|
||
|
|
pre_install_scripts.append(Task(
|
||
|
|
"Run %pre-install scripts",
|
||
|
|
runPreInstallScripts, (ksdata.scripts,)
|
||
|
|
))
|
||
|
|
installation_queue.append(pre_install_scripts)
|
||
|
|
|
||
|
|
# Do various pre-installation tasks
|
||
|
|
# - try to discover a realm (if any)
|
||
|
|
# - check for possibly needed additional packages.
|
||
|
|
pre_install = TaskQueue(
|
||
|
|
"Pre install tasks",
|
||
|
|
_("Running pre-installation tasks"),
|
||
|
|
CATEGORY_SOFTWARE
|
||
|
|
)
|
||
|
|
|
||
|
|
# Make name resolution work for rpm scripts in chroot.
|
||
|
|
# Also make sure dns resolution works in %post scripts
|
||
|
|
# when systemd-resolved is not available.
|
||
|
|
if conf.system.provides_resolver_config and \
|
||
|
|
not is_service_installed("systemd-resolved.service"):
|
||
|
|
pre_install.append(Task(
|
||
|
|
"Copy resolv.conf to sysroot",
|
||
|
|
network.copy_resolv_conf_to_root,
|
||
|
|
(conf.target.system_root, )
|
||
|
|
))
|
||
|
|
|
||
|
|
if is_module_available(SECURITY):
|
||
|
|
security_proxy = SECURITY.get_proxy()
|
||
|
|
|
||
|
|
# Discover a realm.
|
||
|
|
pre_install.append_dbus_tasks(SECURITY, [
|
||
|
|
security_proxy.DiscoverRealmWithTask()
|
||
|
|
])
|
||
|
|
|
||
|
|
# Set up FIPS for the payload installation.
|
||
|
|
fips_task = security_proxy.PreconfigureFIPSWithTask(payload.type)
|
||
|
|
pre_install.append_dbus_tasks(SECURITY, [fips_task])
|
||
|
|
|
||
|
|
# Install the payload.
|
||
|
|
pre_install.append(Task(
|
||
|
|
"Find additional packages & run pre_install()",
|
||
|
|
payload.pre_install
|
||
|
|
))
|
||
|
|
installation_queue.append(pre_install)
|
||
|
|
|
||
|
|
payload_install = TaskQueue(
|
||
|
|
"Payload installation",
|
||
|
|
_("Installing the software"),
|
||
|
|
CATEGORY_SOFTWARE
|
||
|
|
)
|
||
|
|
payload_install.append(Task(
|
||
|
|
"Install the payload",
|
||
|
|
payload.install
|
||
|
|
))
|
||
|
|
installation_queue.append(payload_install)
|
||
|
|
|
||
|
|
# for some payloads storage is configured after the payload is installed
|
||
|
|
if payload.type != PAYLOAD_TYPE_DNF:
|
||
|
|
late_storage = TaskQueue(
|
||
|
|
"Late storage configuration",
|
||
|
|
_("Configuring storage"),
|
||
|
|
CATEGORY_STORAGE,
|
||
|
|
)
|
||
|
|
conf_task = storage_proxy.WriteConfigurationWithTask()
|
||
|
|
late_storage.append_dbus_tasks(STORAGE, [conf_task])
|
||
|
|
installation_queue.append(late_storage)
|
||
|
|
|
||
|
|
# Do bootloader.
|
||
|
|
bootloader_proxy = STORAGE.get_proxy(BOOTLOADER)
|
||
|
|
bootloader_install = TaskQueue(
|
||
|
|
"Bootloader installation",
|
||
|
|
_("Installing boot loader"),
|
||
|
|
CATEGORY_BOOTLOADER
|
||
|
|
)
|
||
|
|
|
||
|
|
def run_configure_bootloader():
|
||
|
|
tasks = boss_proxy.CollectConfigureBootloaderTasks(
|
||
|
|
payload.kernel_version_list
|
||
|
|
)
|
||
|
|
|
||
|
|
for service, task in tasks:
|
||
|
|
sync_run_task(DBus.get_proxy(service, task))
|
||
|
|
|
||
|
|
bootloader_install.append(Task(
|
||
|
|
"Configure bootloader",
|
||
|
|
run_configure_bootloader
|
||
|
|
))
|
||
|
|
|
||
|
|
def run_install_bootloader():
|
||
|
|
tasks = bootloader_proxy.InstallBootloaderWithTasks(
|
||
|
|
payload.type,
|
||
|
|
payload.kernel_version_list
|
||
|
|
)
|
||
|
|
|
||
|
|
for task in tasks:
|
||
|
|
sync_run_task(STORAGE.get_proxy(task))
|
||
|
|
|
||
|
|
bootloader_install.append(Task(
|
||
|
|
"Install bootloader",
|
||
|
|
run_install_bootloader
|
||
|
|
))
|
||
|
|
installation_queue.append(bootloader_install)
|
||
|
|
|
||
|
|
post_install = TaskQueue(
|
||
|
|
"Post-installation setup tasks",
|
||
|
|
_("Performing post-installation setup tasks"),
|
||
|
|
CATEGORY_SYSTEM
|
||
|
|
)
|
||
|
|
post_install.append(Task(
|
||
|
|
"Run post-installation setup tasks",
|
||
|
|
payload.post_install
|
||
|
|
))
|
||
|
|
installation_queue.append(post_install)
|
||
|
|
|
||
|
|
# Create snapshot
|
||
|
|
snapshot_proxy = STORAGE.get_proxy(SNAPSHOT)
|
||
|
|
|
||
|
|
if snapshot_proxy.IsRequested(SNAPSHOT_WHEN_POST_INSTALL):
|
||
|
|
snapshot_creation = TaskQueue(
|
||
|
|
"Creating post installation snapshots",
|
||
|
|
_("Creating snapshots"),
|
||
|
|
CATEGORY_STORAGE
|
||
|
|
)
|
||
|
|
snapshot_task = snapshot_proxy.CreateWithTask(SNAPSHOT_WHEN_POST_INSTALL)
|
||
|
|
snapshot_creation.append_dbus_tasks(STORAGE, [snapshot_task])
|
||
|
|
installation_queue.append(snapshot_creation)
|
||
|
|
|
||
|
|
return installation_queue
|
||
|
|
|
||
|
|
def _run_installation(self, payload, ksdata):
|
||
|
|
"""Run the complete installation."""
|
||
|
|
# before building the install task queue make
|
||
|
|
# sure no backgrond processing threads are running and
|
||
|
|
# the Anaconda internal state is thus final
|
||
|
|
self._wait_for_threads_to_finish()
|
||
|
|
|
||
|
|
queue = TaskQueue("Complete installation queue")
|
||
|
|
queue.append(self._prepare_installation(payload, ksdata))
|
||
|
|
queue.append(self._prepare_configuration(payload, ksdata))
|
||
|
|
|
||
|
|
# Set the progress reporting callback of the payload class.
|
||
|
|
# FIXME: This is a temporary workaround.
|
||
|
|
payload._progress_cb = self._progress_report_cb
|
||
|
|
|
||
|
|
# Set the progress reporting callback of the DBus tasks.
|
||
|
|
# FIXME: This is a temporary workaround.
|
||
|
|
for item in queue.nested_items:
|
||
|
|
if isinstance(item, DBusTask):
|
||
|
|
item._progress_cb = self._progress_report_cb
|
||
|
|
|
||
|
|
# notify progress tracking about the number of steps
|
||
|
|
self._total_steps = queue.task_count
|
||
|
|
|
||
|
|
# log contents of the main task queue
|
||
|
|
log.info(queue.summary)
|
||
|
|
|
||
|
|
# log tasks and queues when they are started
|
||
|
|
# - note that we are using generators to add the counter
|
||
|
|
queue_counter = util.item_counter(queue.queue_count)
|
||
|
|
task_started_counter = util.item_counter(queue.task_count)
|
||
|
|
task_completed_counter = util.item_counter(queue.task_count)
|
||
|
|
queue.queue_started.connect(
|
||
|
|
lambda x: log.info("Queue started: %s (%s)", x.name, next(queue_counter))
|
||
|
|
)
|
||
|
|
queue.task_started.connect(
|
||
|
|
lambda x: log.info("Task started: %s (%s)", x.name, next(task_started_counter))
|
||
|
|
)
|
||
|
|
queue.task_completed.connect(
|
||
|
|
lambda x: log.debug("Task completed: %s (%s) (%1.1f s)", x.name,
|
||
|
|
next(task_completed_counter), x.elapsed_time)
|
||
|
|
)
|
||
|
|
|
||
|
|
# start the task queue
|
||
|
|
queue.start()
|
||
|
|
|
||
|
|
# done
|
||
|
|
self.report_progress(_("Complete!"), step_number=self.steps)
|
||
|
|
|
||
|
|
# this message is automatically detected by QE tools, do not change it lightly
|
||
|
|
log.info(
|
||
|
|
"All tasks in the installation queue are done. "
|
||
|
|
"Installation successfully finished."
|
||
|
|
)
|